Add comprehensive tests for Stripe checkout sessions

This adds test coverage for both purchase modes to prevent regressions:

## Subscription checkout tests (4 tests)
- Verifies subscription_data metadata is passed correctly
- Verifies payment_intent_data is NOT passed (validates fix from #2)
- Verifies checkout session delegation works
- Verifies all plan configuration is included in metadata

## Credit pack checkout tests (5 tests)
- Verifies payment mode is used for one-time purchases
- Verifies payment_intent_data IS passed (correct for payment mode)
- Verifies all pack configuration in metadata
- Verifies product name and description
- Verifies error handling

These tests validate the fix in PR #2 by @cole-robertson and ensure
both subscription and one-time purchase flows work correctly with
Stripe's API requirements.

According to Stripe API docs, payment_intent_data is only valid for
mode: "payment" checkout sessions, not mode: "subscription". The gem
correctly uses:
- payment_intent_data for credit packs (payment mode)
- subscription_data for subscriptions (subscription mode)

Relates-to: #2

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

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: rameerez

.gitignore

@@ -26,6 +26,7 @@ pay.md
 deploy.yml
 
 test/dummy/log/*
+test/coverage/*
 
 .cursor/
 .claude/

test/models/usage_credits/credit_pack_test.rb

@@ -396,4 +396,151 @@ class UsageCredits::CreditPackTest < ActiveSupport::TestCase
     assert_equal 0.99, pack.price
     assert pack.validate!
   end
+
+  # ========================================
+  # STRIPE CHECKOUT SESSION CREATION
+  # ========================================
+
+  test "create_checkout_session uses payment mode for one-time purchases" do
+    pack = UsageCredits::CreditPack.new(:starter)
+    pack.gives(1000)
+    pack.costs(49.dollars)
+
+    user = users(:rich_user)
+
+    # Mock the payment processor to verify the arguments passed
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    # Verify payment mode is used (not subscription mode)
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      assert_equal "payment", args[:mode], "Credit packs should use payment mode"
+      assert args[:line_items].present?, "line_items should be present"
+
+      # Verify line items structure
+      line_item = args[:line_items].first
+      assert line_item[:price_data].present?, "price_data should be present for dynamic pricing"
+      assert_equal "usd", line_item[:price_data][:currency]
+      assert_equal 4900, line_item[:price_data][:unit_amount]
+      assert_equal 1, line_item[:quantity]
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      pack.create_checkout_session(user)
+    end
+
+    mock_payment_processor.verify
+  end
+
+  test "create_checkout_session passes payment_intent_data for payment mode" do
+    pack = UsageCredits::CreditPack.new(:pro)
+    pack.gives(5000)
+    pack.costs(99.dollars)
+
+    user = users(:rich_user)
+
+    # Mock the payment processor to verify payment_intent_data is passed
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    # For payment mode, payment_intent_data IS allowed and should be present
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      assert_equal "payment", args[:mode]
+
+      # payment_intent_data is VALID for payment mode (unlike subscription mode)
+      assert args.key?(:payment_intent_data), "payment_intent_data should be present for payment mode"
+      assert args[:payment_intent_data][:metadata].present?, "payment_intent_data metadata should be present"
+
+      # Verify metadata contains pack info
+      metadata = args[:payment_intent_data][:metadata]
+      assert_equal "credit_pack", metadata[:purchase_type]
+      assert_equal :pro, metadata[:pack_name]
+      assert_equal 5000, metadata[:credits]
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      pack.create_checkout_session(user)
+    end
+
+    mock_payment_processor.verify
+  end
+
+  test "create_checkout_session includes all pack configuration in metadata" do
+    pack = UsageCredits::CreditPack.new(:enterprise)
+    pack.gives(10_000)
+    pack.bonus(2_000)
+    pack.costs(199.dollars)
+
+    user = users(:rich_user)
+
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      metadata = args[:payment_intent_data][:metadata]
+
+      # Verify all pack configuration is included
+      assert_equal "credit_pack", metadata[:purchase_type]
+      assert_equal :enterprise, metadata[:pack_name]
+      assert_equal 10_000, metadata[:credits]
+      assert_equal 2_000, metadata[:bonus_credits]
+      assert_equal 19900, metadata[:price_cents]
+      assert_equal "USD", metadata[:price_currency]
+
+      # Also verify session-level metadata
+      assert_equal metadata, args[:metadata], "Session metadata should match payment_intent_data metadata"
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      pack.create_checkout_session(user)
+    end
+
+    mock_payment_processor.verify
+  end
+
+  test "create_checkout_session raises when user has no payment processor" do
+    pack = UsageCredits::CreditPack.new(:test)
+    pack.gives(100)
+    pack.costs(10.dollars)
+
+    user_without_payment = Object.new
+
+    error = assert_raises(ArgumentError) do
+      pack.create_checkout_session(user_without_payment)
+    end
+
+    assert_includes error.message, "must have a payment processor"
+  end
+
+  test "create_checkout_session includes product name and description" do
+    pack = UsageCredits::CreditPack.new(:starter)
+    pack.gives(1000)
+    pack.costs(49.dollars)
+
+    user = users(:rich_user)
+
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      product_data = args[:line_items].first[:price_data][:product_data]
+
+      assert_equal "Starter pack", product_data[:name]
+      assert_equal "1000 credits", product_data[:description]
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      pack.create_checkout_session(user)
+    end
+
+    mock_payment_processor.verify
+  end
 end

test/models/usage_credits/credit_subscription_plan_test.rb

@@ -532,4 +532,148 @@ class UsageCredits::CreditSubscriptionPlanTest < ActiveSupport::TestCase
 
     assert_kind_of ActiveSupport::Duration, parsed
   end
+
+  # ========================================
+  # STRIPE CHECKOUT SESSION CREATION
+  # ========================================
+
+  test "create_stripe_checkout_session passes subscription_data metadata" do
+    plan = UsageCredits::CreditSubscriptionPlan.new(:premium)
+    plan.gives(1000).every(:month)
+    plan.signup_bonus(200)
+    plan.trial_includes(50)
+    plan.stripe_price("price_123")
+
+    user = users(:rich_user)
+
+    # Mock the payment processor to verify the arguments passed
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    # Expect checkout to be called with subscription_data but NOT payment_intent_data
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      assert_equal "subscription", args[:mode]
+      assert_equal "price_123", args[:line_items].first[:price]
+      assert_equal 1, args[:line_items].first[:quantity]
+      assert args[:subscription_data].present?, "subscription_data should be present"
+      assert args[:subscription_data][:metadata].present?, "subscription_data metadata should be present"
+
+      # Verify metadata contains all required fields
+      metadata = args[:subscription_data][:metadata]
+      assert_equal "credit_subscription", metadata[:purchase_type]
+      assert_equal :premium, metadata[:subscription_name]
+      assert_equal 1000, metadata[:credits_per_period]
+      assert_equal 200, metadata[:signup_bonus_credits]
+      assert_equal 50, metadata[:trial_credits]
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      plan.create_stripe_checkout_session(user, "price_123", "/success", "/cancel")
+    end
+
+    mock_payment_processor.verify
+  end
+
+  test "create_stripe_checkout_session does not pass payment_intent_data for subscription mode" do
+    plan = UsageCredits::CreditSubscriptionPlan.new(:basic)
+    plan.gives(500).every(:month)
+    plan.stripe_price("price_456")
+
+    user = users(:rich_user)
+
+    # Mock the payment processor to verify payment_intent_data is NOT passed
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    # Verify that payment_intent_data is NOT in the arguments
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      # According to Stripe API, payment_intent_data is only allowed for mode: "payment"
+      # For mode: "subscription", it should not be present
+      refute args.key?(:payment_intent_data), "payment_intent_data should not be present for subscription mode checkout sessions"
+
+      # But subscription_data should be present
+      assert args.key?(:subscription_data), "subscription_data should be present for subscription mode"
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      plan.create_stripe_checkout_session(user, "price_456", "/success", "/cancel")
+    end
+
+    mock_payment_processor.verify
+  end
+
+  test "create_checkout_session delegates to create_stripe_checkout_session for stripe processor" do
+    plan = UsageCredits::CreditSubscriptionPlan.new(:test)
+    plan.gives(500).every(:month)
+    plan.stripe_price("price_789")
+
+    user = users(:rich_user)
+
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |_args|
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      result = plan.create_checkout_session(
+        user,
+        success_url: "/success",
+        cancel_url: "/cancel",
+        processor: :stripe
+      )
+
+      assert_equal "https://checkout.stripe.com/test", result.url
+    end
+
+    mock_payment_processor.verify
+  end
+
+  test "create_checkout_session includes all plan configuration in metadata" do
+    plan = UsageCredits::CreditSubscriptionPlan.new(:enterprise)
+    plan.gives(10_000).every(:month)
+    plan.signup_bonus(1_000)
+    plan.trial_includes(500)
+    plan.unused_credits(:rollover)
+    plan.expire_after(30.days)
+    plan.meta(tier: "enterprise", max_users: 100)
+    plan.stripe_price("price_enterprise")
+
+    user = users(:rich_user)
+
+    mock_payment_processor = Minitest::Mock.new
+    mock_checkout_session = OpenStruct.new(url: "https://checkout.stripe.com/test")
+
+    mock_payment_processor.expect(:checkout, mock_checkout_session) do |args|
+      metadata = args[:subscription_data][:metadata]
+
+      # Verify all configuration is included
+      assert_equal "credit_subscription", metadata[:purchase_type]
+      assert_equal :enterprise, metadata[:subscription_name]
+      assert_equal 10_000, metadata[:credits_per_period]
+      assert_equal 1_000, metadata[:signup_bonus_credits]
+      assert_equal 500, metadata[:trial_credits]
+      assert_equal true, metadata[:rollover_enabled]
+      assert_equal true, metadata[:expire_credits_on_cancel]
+      assert_equal 30.days.to_i, metadata[:credit_expiration_period]
+      assert_equal({ tier: "enterprise", max_users: 100 }, metadata[:metadata])
+
+      true
+    end
+
+    user.stub(:payment_processor, mock_payment_processor) do
+      plan.create_checkout_session(
+        user,
+        success_url: "/success",
+        cancel_url: "/cancel"
+      )
+    end
+
+    mock_payment_processor.verify
+  end
 end