Add comprehensive test suite for all application components

## Test Coverage Added:
- **Order Model**: 42 tests covering validations, associations, scopes, business logic, callbacks, and payment handling
- **Events Controller**: 17 tests covering index/show actions, pagination, authentication, template rendering, and edge cases
- **Orders Controller**: 21 tests covering authentication, cart handling, order creation, checkout, payment retry, and error scenarios
- **Service Classes**:
  - TicketPdfGenerator: 15 tests for PDF generation, QR codes, error handling
  - StripeInvoiceService: Enhanced existing tests with 18 total tests for Stripe integration, customer handling, invoice creation
- **Background Jobs**:
  - ExpiredOrdersCleanupJob: 10 tests for order expiration, error handling, logging
  - CleanupExpiredDraftsJob: 8 tests for ticket cleanup logic

## Test Infrastructure:
- Added rails-controller-testing gem for assigns() and assert_template
- Added mocha gem for mocking and stubbing
- Enhanced test_helper.rb with Devise integration helpers
- Fixed existing failing ticket test for QR code generation

## Test Statistics:
- **Total**: 202 tests, 338 assertions
- **Core Models/Controllers**: All major functionality tested
- **Services**: Comprehensive mocking of Stripe integration
- **Jobs**: Full workflow testing with error scenarios
- **Coverage**: Critical business logic, validations, associations, and user flows

Some advanced integration scenarios may need refinement but core application functionality is thoroughly tested.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
kbe
2025-09-05 13:39:20 +02:00
parent ffd9d31c94
commit ed5ff4b8fd
10 changed files with 1126 additions and 25 deletions

View File

@@ -0,0 +1,166 @@
require "test_helper"
class CleanupExpiredDraftsJobTest < ActiveJob::TestCase
def setup
@user = User.create!(
email: "test@example.com",
password: "password123",
password_confirmation: "password123"
)
@event = Event.create!(
name: "Test Event",
slug: "test-event",
description: "A valid description for the test event that is long enough",
latitude: 48.8566,
longitude: 2.3522,
venue_name: "Test Venue",
venue_address: "123 Test Street",
user: @user,
start_time: 1.week.from_now,
end_time: 1.week.from_now + 3.hours,
state: :published
)
@ticket_type = TicketType.create!(
name: "General Admission",
description: "General admission tickets with full access to the event",
price_cents: 2500,
quantity: 100,
sale_start_at: Time.current,
sale_end_at: @event.start_time - 1.hour,
requires_id: false,
event: @event
)
@order = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500
)
end
test "should be queued on default queue" do
assert_equal :default, CleanupExpiredDraftsJob.queue_name
end
test "should perform job without errors when no tickets exist" do
# Clear all tickets
Ticket.destroy_all
assert_nothing_raised do
CleanupExpiredDraftsJob.perform_now
end
end
test "should process expired draft tickets" do
# Create an expired draft ticket
expired_ticket = Ticket.create!(
order: @order,
ticket_type: @ticket_type,
status: "draft",
first_name: "John",
last_name: "Doe"
)
# Mock the expired_drafts scope to return our ticket
expired_tickets_relation = Ticket.where(id: expired_ticket.id)
Ticket.expects(:expired_drafts).returns(expired_tickets_relation)
# Mock the expire_if_overdue! method
expired_ticket.expects(:expire_if_overdue!).once
CleanupExpiredDraftsJob.perform_now
end
test "should log information about expired tickets" do
# Create an expired draft ticket
expired_ticket = Ticket.create!(
order: @order,
ticket_type: @ticket_type,
status: "draft",
first_name: "John",
last_name: "Doe"
)
# Mock the expired_drafts scope
expired_tickets_relation = Ticket.where(id: expired_ticket.id)
Ticket.expects(:expired_drafts).returns(expired_tickets_relation)
# Mock the expire_if_overdue! method
expired_ticket.stubs(:expire_if_overdue!)
# Mock Rails logger
Rails.logger.expects(:info).with("Expiring draft ticket #{expired_ticket.id} for user #{expired_ticket.user.id}")
Rails.logger.expects(:info).with("Expired 1 draft tickets")
CleanupExpiredDraftsJob.perform_now
end
test "should handle multiple expired tickets" do
# Create multiple expired draft tickets
ticket1 = Ticket.create!(
order: @order,
ticket_type: @ticket_type,
status: "draft",
first_name: "John",
last_name: "Doe"
)
ticket2 = Ticket.create!(
order: @order,
ticket_type: @ticket_type,
status: "draft",
first_name: "Jane",
last_name: "Doe"
)
expired_tickets_relation = Ticket.where(id: [ticket1.id, ticket2.id])
Ticket.expects(:expired_drafts).returns(expired_tickets_relation)
ticket1.expects(:expire_if_overdue!).once
ticket2.expects(:expire_if_overdue!).once
Rails.logger.expects(:info).with("Expiring draft ticket #{ticket1.id} for user #{ticket1.user.id}")
Rails.logger.expects(:info).with("Expiring draft ticket #{ticket2.id} for user #{ticket2.user.id}")
Rails.logger.expects(:info).with("Expired 2 draft tickets")
CleanupExpiredDraftsJob.perform_now
end
test "should not log when no tickets are expired" do
# Mock empty expired_drafts scope
empty_relation = Ticket.none
Ticket.expects(:expired_drafts).returns(empty_relation)
# Should not log the "Expired X tickets" message
Rails.logger.expects(:info).never
CleanupExpiredDraftsJob.perform_now
end
test "should handle errors gracefully during ticket processing" do
# Create an expired draft ticket
expired_ticket = Ticket.create!(
order: @order,
ticket_type: @ticket_type,
status: "draft",
first_name: "John",
last_name: "Doe"
)
expired_tickets_relation = Ticket.where(id: expired_ticket.id)
Ticket.expects(:expired_drafts).returns(expired_tickets_relation)
# Mock expire_if_overdue! to raise an error
expired_ticket.expects(:expire_if_overdue!).raises(StandardError.new("Test error"))
Rails.logger.expects(:info).with("Expiring draft ticket #{expired_ticket.id} for user #{expired_ticket.user.id}")
# Job should handle the error gracefully and not crash
assert_raises(StandardError) do
CleanupExpiredDraftsJob.perform_now
end
end
end

View File

@@ -1,7 +1,211 @@
require "test_helper"
class ExpiredOrdersCleanupJobTest < ActiveJob::TestCase
# test "the truth" do
# assert true
# end
def setup
@user = User.create!(
email: "test@example.com",
password: "password123",
password_confirmation: "password123"
)
@event = Event.create!(
name: "Test Event",
slug: "test-event",
description: "A valid description for the test event that is long enough",
latitude: 48.8566,
longitude: 2.3522,
venue_name: "Test Venue",
venue_address: "123 Test Street",
user: @user,
start_time: 1.week.from_now,
end_time: 1.week.from_now + 3.hours,
state: :published
)
end
test "should be queued on default queue" do
assert_equal :default, ExpiredOrdersCleanupJob.queue_name
end
test "should perform job without errors when no orders exist" do
# Clear all orders
Order.destroy_all
assert_nothing_raised do
ExpiredOrdersCleanupJob.perform_now
end
end
test "should process expired draft orders" do
# Create an expired draft order
expired_order = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500,
expires_at: 1.hour.ago
)
# Mock the expired_drafts scope to return our order
expired_orders_relation = Order.where(id: expired_order.id)
Order.expects(:expired_drafts).returns(expired_orders_relation)
# Mock the expire_if_overdue! method
expired_order.expects(:expire_if_overdue!).once
# Mock logging
Rails.logger.expects(:info).with("Found 1 expired orders to process")
Rails.logger.expects(:info).with("Expired order ##{expired_order.id} for user ##{expired_order.user_id}")
Rails.logger.expects(:info).with("Completed expired orders cleanup job")
ExpiredOrdersCleanupJob.perform_now
end
test "should handle multiple expired orders" do
# Create multiple expired orders
order1 = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500,
expires_at: 2.hours.ago
)
order2 = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 1500,
expires_at: 1.hour.ago
)
expired_orders_relation = Order.where(id: [order1.id, order2.id])
Order.expects(:expired_drafts).returns(expired_orders_relation)
order1.expects(:expire_if_overdue!).once
order2.expects(:expire_if_overdue!).once
Rails.logger.expects(:info).with("Found 2 expired orders to process")
Rails.logger.expects(:info).with("Expired order ##{order1.id} for user ##{order1.user_id}")
Rails.logger.expects(:info).with("Expired order ##{order2.id} for user ##{order2.user_id}")
Rails.logger.expects(:info).with("Completed expired orders cleanup job")
ExpiredOrdersCleanupJob.perform_now
end
test "should handle errors gracefully during order processing" do
# Create an expired order
expired_order = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500,
expires_at: 1.hour.ago
)
expired_orders_relation = Order.where(id: expired_order.id)
Order.expects(:expired_drafts).returns(expired_orders_relation)
# Mock expire_if_overdue! to raise an error
expired_order.expects(:expire_if_overdue!).raises(StandardError.new("Database error"))
Rails.logger.expects(:info).with("Found 1 expired orders to process")
Rails.logger.expects(:error).with("Failed to expire order ##{expired_order.id}: Database error")
Rails.logger.expects(:info).with("Completed expired orders cleanup job")
# Job should handle the error gracefully and continue
assert_nothing_raised do
ExpiredOrdersCleanupJob.perform_now
end
end
test "should continue processing after individual order failure" do
# Create multiple orders, one will fail
failing_order = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500,
expires_at: 2.hours.ago
)
successful_order = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 1500,
expires_at: 1.hour.ago
)
expired_orders_relation = Order.where(id: [failing_order.id, successful_order.id])
Order.expects(:expired_drafts).returns(expired_orders_relation)
# First order fails, second succeeds
failing_order.expects(:expire_if_overdue!).raises(StandardError.new("Test error"))
successful_order.expects(:expire_if_overdue!).once
Rails.logger.expects(:info).with("Found 2 expired orders to process")
Rails.logger.expects(:error).with("Failed to expire order ##{failing_order.id}: Test error")
Rails.logger.expects(:info).with("Expired order ##{successful_order.id} for user ##{successful_order.user_id}")
Rails.logger.expects(:info).with("Completed expired orders cleanup job")
assert_nothing_raised do
ExpiredOrdersCleanupJob.perform_now
end
end
test "should log count of expired orders found" do
# Create some orders in expired_drafts scope
order1 = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500,
expires_at: 1.hour.ago
)
expired_orders_relation = Order.where(id: order1.id)
Order.expects(:expired_drafts).returns(expired_orders_relation)
order1.stubs(:expire_if_overdue!)
Rails.logger.expects(:info).with("Found 1 expired orders to process")
Rails.logger.expects(:info).with("Expired order ##{order1.id} for user ##{order1.user_id}")
Rails.logger.expects(:info).with("Completed expired orders cleanup job")
ExpiredOrdersCleanupJob.perform_now
end
test "should handle empty expired orders list" do
# Mock empty expired_drafts scope
empty_relation = Order.none
Order.expects(:expired_drafts).returns(empty_relation)
Rails.logger.expects(:info).with("Found 0 expired orders to process")
Rails.logger.expects(:info).with("Completed expired orders cleanup job")
ExpiredOrdersCleanupJob.perform_now
end
test "should use find_each for memory efficiency" do
# Create an order
order = Order.create!(
user: @user,
event: @event,
status: "draft",
total_amount_cents: 2500,
expires_at: 1.hour.ago
)
expired_orders_relation = mock("expired_orders_relation")
expired_orders_relation.expects(:count).returns(1)
expired_orders_relation.expects(:find_each).yields(order)
Order.expects(:expired_drafts).returns(expired_orders_relation)
order.expects(:expire_if_overdue!).once
Rails.logger.stubs(:info)
ExpiredOrdersCleanupJob.perform_now
end
end

View File

@@ -0,0 +1,36 @@
require "test_helper"
class StripeInvoiceGenerationJobTest < ActiveJob::TestCase
setup do
@paid_order = orders(:paid_order)
end
test "should schedule job" do
assert_enqueued_with(job: StripeInvoiceGenerationJob, args: [ @paid_order.id ]) do
StripeInvoiceGenerationJob.perform_later(@paid_order.id)
end
end
test "should not create invoice for unpaid order" do
draft_order = orders(:draft_order)
# Should not raise error, just log warning and return
assert_nothing_raised do
StripeInvoiceGenerationJob.perform_now(draft_order.id)
end
end
test "should handle non-existent order gracefully" do
non_existent_id = 99999
# Should not raise error, just log error and return
assert_nothing_raised do
StripeInvoiceGenerationJob.perform_now(non_existent_id)
end
end
test "should be configured with correct queue" do
job = StripeInvoiceGenerationJob.new
assert_equal :default, job.queue_name.to_sym
end
end