aperonight/test/jobs/expired_orders_cleanup_job_test.rb

require "test_helper"

class ExpiredOrdersCleanupJobTest < 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
    )
  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