redux-scraper/spec/controllers/telegram_bot_logs_controller_spec.rb

# typed: false
require "rails_helper"

RSpec.describe TelegramBotLogsController, type: :controller do
  render_views

  let(:admin_user) { create(:user, role: :admin) }
  let(:regular_user) { create(:user, role: :user) }
  let(:telegram_bot_log) { create(:telegram_bot_log, :successful, :with_image) }

  describe "authorization" do
    context "when user is not signed in" do
      describe "GET #index" do
        it "redirects to sign in" do
          get :index
          expect(response).to redirect_to(new_user_session_path)
        end
      end

      describe "GET #show" do
        it "redirects to sign in" do
          get :show, params: { id: telegram_bot_log.id }
          expect(response).to redirect_to(new_user_session_path)
        end
      end
    end

    context "when regular user is signed in" do
      before { sign_in regular_user }

      describe "GET #index" do
        it "redirects to root with access denied" do
          get :index
          expect(response).to redirect_to(root_path)
          expect(flash[:alert]).to eq(
            "You are not authorized to perform this action.",
          )
        end
      end

      describe "GET #show" do
        it "redirects to root with access denied" do
          get :show, params: { id: telegram_bot_log.id }
          expect(response).to redirect_to(root_path)
          expect(flash[:alert]).to eq(
            "You are not authorized to perform this action.",
          )
        end
      end
    end
  end

  context "when admin user is signed in" do
    before { sign_in admin_user }

    describe "GET #index" do
      it "returns a success response" do
        get :index
        expect(response).to be_successful
        expect(response).to render_template(:index)
      end

      it "assigns telegram_bot_logs with proper pagination" do
        logs = create_list(:telegram_bot_log, 3, :successful)
        get :index
        expect(assigns(:telegram_bot_logs)).to be_present
        expect(assigns(:telegram_bot_logs)).to respond_to(:current_page)
        expect(assigns(:telegram_bot_logs).to_a).to match_array(logs)
      end

      it "respects limit parameter" do
        create_list(:telegram_bot_log, 5, :successful)
        get :index, params: { limit: 2 }
        expect(assigns(:limit)).to eq(2)
        expect(assigns(:telegram_bot_logs).count).to eq(2)
      end

      it "clamps limit parameter within bounds" do
        get :index, params: { limit: 1000 }
        expect(assigns(:limit)).to eq(500) # max limit

        get :index, params: { limit: 0 }
        expect(assigns(:limit)).to eq(1) # min limit
      end

      it "handles pagination parameters" do
        create_list(:telegram_bot_log, 10, :successful)
        get :index, params: { page: 2, limit: 5 }
        expect(assigns(:telegram_bot_logs).current_page).to eq(2)
      end

      it "assigns status options for filtering" do
        get :index
        expect(assigns(:status_options)).to eq(TelegramBotLog.statuses.keys)
      end

      it "assigns filter params" do
        filter_params = {
          telegram_user_id: "123456789",
          status: "successful",
          start_date: "2023-01-01",
          end_date: "2023-12-31",
          min_results: "1",
          max_results: "10",
          slow_requests: "true",
        }

        get :index, params: filter_params
        assigned_params = assigns(:filter_params)
        expect(assigned_params["telegram_user_id"]).to eq("123456789")
        expect(assigned_params["status"]).to eq("successful")
        expect(assigned_params["start_date"]).to eq("2023-01-01")
        expect(assigned_params["end_date"]).to eq("2023-12-31")
        expect(assigned_params["min_results"]).to eq("1")
        expect(assigned_params["max_results"]).to eq("10")
        expect(assigned_params["slow_requests"]).to eq("true")
      end

      describe "filtering" do
        let!(:user_123_log) do
          create(:telegram_bot_log, :successful, telegram_user_id: 123_456_789)
        end
        let!(:user_456_log) do
          create(:telegram_bot_log, :successful, telegram_user_id: 456_789_123)
        end
        let!(:error_log) { create(:telegram_bot_log, :with_error) }
        let!(:no_results_log) { create(:telegram_bot_log, :with_no_results) }

        it "filters by telegram_user_id" do
          get :index, params: { telegram_user_id: "123456789" }
          logs = assigns(:telegram_bot_logs).to_a
          expect(logs).to include(user_123_log)
          expect(logs).not_to include(user_456_log)
        end

        it "filters by status" do
          get :index, params: { status: "error" }
          logs = assigns(:telegram_bot_logs).to_a
          expect(logs).to include(error_log)
          expect(logs).not_to include(user_123_log)
        end

        it "filters by search results count range" do
          high_results_log =
            create(:telegram_bot_log, :successful, search_results_count: 5)
          low_results_log =
            create(:telegram_bot_log, :successful, search_results_count: 1)

          get :index, params: { min_results: "3" }
          logs = assigns(:telegram_bot_logs).to_a
          expect(logs).to include(high_results_log)
          expect(logs).not_to include(low_results_log)
        end

        it "filters by date range" do
          old_log =
            create(
              :telegram_bot_log,
              :successful,
              request_timestamp: 1.week.ago,
            )
          new_log =
            create(:telegram_bot_log, :successful, request_timestamp: 1.day.ago)

          get :index,
              params: {
                start_date: 3.days.ago.to_date.to_s,
                end_date: Date.current.to_s,
              }
          logs = assigns(:telegram_bot_logs).to_a
          expect(logs).to include(new_log)
          expect(logs).not_to include(old_log)
        end

        it "filters slow requests" do
          fast_log =
            create(
              :telegram_bot_log,
              :successful,
              fingerprint_computation_time: 0.1,
              search_computation_time: 0.2,
              total_request_time: 0.3,
            )
          slow_log =
            create(
              :telegram_bot_log,
              :successful,
              fingerprint_computation_time: 0.8,
              search_computation_time: 0.9,
              total_request_time: 6.0,
            )

          get :index, params: { slow_requests: "true" }
          logs = assigns(:telegram_bot_logs).to_a
          expect(logs).to include(slow_log)
          expect(logs).not_to include(fast_log)
        end
      end

      describe "includes associations" do
        it "includes processed_image association" do
          create(:telegram_bot_log, :with_image)
          get :index

          # Verify the association is loaded
          expect(
            assigns(:telegram_bot_logs).first&.processed_image,
          ).to be_present
        end
      end

      describe "error handling" do
        it "handles invalid filter parameters gracefully" do
          get :index,
              params: {
                start_date: "invalid-date",
                min_results: "not-a-number",
              }
          expect(response).to be_successful
          expect(assigns(:telegram_bot_logs)).not_to be_nil
        end
      end
    end

    describe "GET #show" do
      let(:telegram_bot_log) do
        create(:telegram_bot_log, :successful, :with_image)
      end

      it "returns a success response" do
        get :show, params: { id: telegram_bot_log.id }
        expect(response).to be_successful
        expect(response).to render_template(:show)
      end

      it "assigns the requested telegram_bot_log" do
        get :show, params: { id: telegram_bot_log.id }
        expect(assigns(:telegram_bot_log)).to eq(telegram_bot_log)
      end

      it "includes processed_image association" do
        get :show, params: { id: telegram_bot_log.id }

        # Verify the association is loaded
        expect(assigns(:telegram_bot_log).processed_image).to be_present
      end

      it "handles non-existent log gracefully" do
        get :show, params: { id: 999_999 }
        expect(response).to redirect_to(telegram_bot_logs_path)
        expect(flash[:alert]).to eq("Telegram bot log not found.")
      end
    end
  end

  describe "performance" do
    context "with many records" do
      before { create_list(:telegram_bot_log, 100, :successful) }

      it "loads records successfully with many logs" do
        sign_in admin_user

        get :index, params: { limit: 50 }
        expect(response).to be_successful
        expect(assigns(:telegram_bot_logs).count).to eq(50)
      end
    end
  end
end