268 lines
8.5 KiB
Ruby
268 lines
8.5 KiB
Ruby
# 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, :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,
|
|
)
|
|
slow_log =
|
|
create(
|
|
:telegram_bot_log,
|
|
:successful,
|
|
fingerprint_computation_time: 0.8,
|
|
search_computation_time: 0.9,
|
|
)
|
|
|
|
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
|