stripe-ruby-mock 3.1.0.rc3 → 3.1.0

data/lib/stripe_mock/webhook_fixtures/subscription_schedule.released.json

@@ -0,0 +1,111 @@
+{
+  "id": "evt_000000000000000000000000",
+  "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1648320106,
+  "data": {
+    "object": {
+      "id": "sub_sched_000000000000000000000000",
+      "object": "subscription_schedule",
+      "canceled_at": null,
+      "completed_at": null,
+      "created": 1648320105,
+      "current_phase": null,
+      "customer": "cus_00000000000000",
+      "default_settings": {
+        "application_fee_percent": null,
+        "automatic_tax": {
+          "enabled": false
+        },
+        "billing_cycle_anchor": "automatic",
+        "billing_thresholds": null,
+        "collection_method": "charge_automatically",
+        "default_payment_method": null,
+        "default_source": null,
+        "invoice_settings": null,
+        "transfer_data": null
+      },
+      "end_behavior": "release",
+      "livemode": false,
+      "metadata": {
+      },
+      "phases": [
+        {
+          "add_invoice_items": [
+
+          ],
+          "application_fee_percent": null,
+          "billing_cycle_anchor": null,
+          "billing_thresholds": null,
+          "collection_method": null,
+          "coupon": null,
+          "default_payment_method": null,
+          "default_tax_rates": [
+
+          ],
+          "end_date": 1650998505,
+          "invoice_settings": null,
+          "items": [
+            {
+              "billing_thresholds": null,
+              "plan": "price_000000000000000000000000",
+              "price": "price_000000000000000000000000",
+              "quantity": 1,
+              "tax_rates": [
+
+              ]
+            }
+          ],
+          "proration_behavior": "create_prorations",
+          "start_date": 1648320105,
+          "transfer_data": null,
+          "trial_end": null
+        },
+        {
+          "add_invoice_items": [
+
+          ],
+          "application_fee_percent": null,
+          "billing_cycle_anchor": null,
+          "billing_thresholds": null,
+          "collection_method": null,
+          "coupon": null,
+          "default_payment_method": null,
+          "default_tax_rates": [
+
+          ],
+          "end_date": 1653590505,
+          "invoice_settings": null,
+          "items": [
+            {
+              "billing_thresholds": null,
+              "plan": "price_000000000000000000000000",
+              "price": "price_000000000000000000000000",
+              "quantity": 2,
+              "tax_rates": [
+
+              ]
+            }
+          ],
+          "proration_behavior": "create_prorations",
+          "start_date": 1650998505,
+          "transfer_data": null,
+          "trial_end": null
+        }
+      ],
+      "released_at": 1648320106,
+      "released_subscription": "sub_000000000000000000000000",
+      "renewal_interval": null,
+      "status": "released",
+      "subscription": null,
+      "test_clock": null
+    }
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": "req_00000000000000",
+    "idempotency_key": "fe5a111d-ed6f-4cb5-a33c-05b364afc565"
+  },
+  "type": "subscription_schedule.released"
+}

data/lib/stripe_mock/webhook_fixtures/subscription_schedule.updated.json

@@ -0,0 +1,125 @@
+{
+  "id": "evt_000000000000000000000000",
+  "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1648320111,
+  "data": {
+    "object": {
+      "id": "sub_sched_000000000000000000000000",
+      "object": "subscription_schedule",
+      "canceled_at": null,
+      "completed_at": null,
+      "created": 1648320110,
+      "current_phase": {
+        "end_date": 1650998510,
+        "start_date": 1648320110
+      },
+      "customer": "cus_00000000000000",
+      "default_settings": {
+        "application_fee_percent": null,
+        "automatic_tax": {
+          "enabled": false
+        },
+        "billing_cycle_anchor": "automatic",
+        "billing_thresholds": null,
+        "collection_method": "charge_automatically",
+        "default_payment_method": null,
+        "default_source": null,
+        "invoice_settings": {
+          "days_until_due": null
+        },
+        "transfer_data": null
+      },
+      "end_behavior": "release",
+      "livemode": false,
+      "metadata": {
+        "foo": "bar"
+      },
+      "phases": [
+        {
+          "add_invoice_items": [
+
+          ],
+          "application_fee_percent": null,
+          "billing_cycle_anchor": null,
+          "billing_thresholds": null,
+          "collection_method": null,
+          "coupon": null,
+          "default_payment_method": null,
+          "default_tax_rates": [
+
+          ],
+          "end_date": 1650998510,
+          "invoice_settings": null,
+          "items": [
+            {
+              "billing_thresholds": null,
+              "plan": "price_000000000000000000000000",
+              "price": "price_000000000000000000000000",
+              "quantity": 1,
+              "tax_rates": [
+
+              ]
+            }
+          ],
+          "proration_behavior": "create_prorations",
+          "start_date": 1648320110,
+          "transfer_data": null,
+          "trial_end": null
+        },
+        {
+          "add_invoice_items": [
+
+          ],
+          "application_fee_percent": null,
+          "billing_cycle_anchor": null,
+          "billing_thresholds": null,
+          "collection_method": null,
+          "coupon": null,
+          "default_payment_method": null,
+          "default_tax_rates": [
+
+          ],
+          "end_date": 1653590510,
+          "invoice_settings": null,
+          "items": [
+            {
+              "billing_thresholds": null,
+              "plan": "price_000000000000000000000000",
+              "price": "price_000000000000000000000000",
+              "quantity": 2,
+              "tax_rates": [
+
+              ]
+            }
+          ],
+          "proration_behavior": "create_prorations",
+          "start_date": 1650998510,
+          "transfer_data": null,
+          "trial_end": null
+        }
+      ],
+      "released_at": null,
+      "released_subscription": null,
+      "renewal_interval": null,
+      "status": "active",
+      "subscription": "sub_000000000000000000000000",
+      "test_clock": null
+    },
+    "previous_attributes": {
+      "default_settings": {
+        "invoice_settings": null
+      },
+      "metadata": {
+        "foo": null
+      }
+    }
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": "req_00000000000000",
+    "idempotency_key": "209a08f0-224b-410a-b659-a0a39a7c59b6"
+  },
+  "type": "subscription_schedule.updated"
+}

data/lib/stripe_mock/webhook_fixtures/tax_rate.created.json

@@ -0,0 +1,32 @@
+{
+  "id": "evt_000000000000000000000000",
+  "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1700752531,
+  "data": {
+    "object": {
+      "id": "txr_00000000000000",
+      "object": "tax_rate",
+      "active": true,
+      "country": "DE",
+      "created": 1700750289,
+      "description": "VAT Germany",
+      "display_name": "VAT",
+      "effective_percentage": null,
+      "inclusive": false,
+      "jurisdiction": "DE",
+      "livemode": false,
+      "metadata": {},
+      "percentage": 16.0,
+      "state": null,
+      "tax_type": "vat"
+    }
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": "req_00000000000000",
+    "idempotency_key": "cd3e4fc0-9d4c-42fd-a818-1b9789537ce9"
+  },
+  "type": "tax_rate.created"
+}

data/lib/stripe_mock/webhook_fixtures/tax_rate.updated.json

@@ -0,0 +1,37 @@
+{
+  "id": "evt_000000000000000000000000",
+  "object": "event",
+  "api_version": "2020-08-27",
+  "created": 1700752371,
+  "data": {
+    "object": {
+      "id": "txr_00000000000000",
+      "object": "tax_rate",
+      "active": true,
+      "country": "DE",
+      "created": 1700750289,
+      "description": "VAT Germany",
+      "display_name": "VAT",
+      "effective_percentage": null,
+      "inclusive": false,
+      "jurisdiction": "DE",
+      "livemode": false,
+      "metadata": {},
+      "percentage": 16.0,
+      "state": null,
+      "tax_type": "vat"
+    },
+    "previous_attributes": {
+      "metadata": {
+        "foo": null
+      }
+    }
+  },
+  "livemode": false,
+  "pending_webhooks": 2,
+  "request": {
+    "id": "req_00000000000000",
+    "idempotency_key": "7eb234a6-64bc-4320-bc7f-780c546ab026"
+  },
+  "type": "tax_rate.updated"
+}

data/lib/stripe_mock.rb

@@ -65,6 +65,7 @@ require 'stripe_mock/request_handlers/invoice_items.rb'
 require 'stripe_mock/request_handlers/orders.rb'
 require 'stripe_mock/request_handlers/plans.rb'
 require 'stripe_mock/request_handlers/prices.rb'
+require 'stripe_mock/request_handlers/promotion_codes.rb'
 require 'stripe_mock/request_handlers/recipients.rb'
 require 'stripe_mock/request_handlers/refunds.rb'
 require 'stripe_mock/request_handlers/transfers.rb'
@@ -79,7 +80,6 @@ require 'stripe_mock/request_handlers/country_spec.rb'
 require 'stripe_mock/request_handlers/ephemeral_key.rb'
 require 'stripe_mock/request_handlers/products.rb'
 require 'stripe_mock/request_handlers/tax_rates.rb'
-require 'stripe_mock/request_handlers/checkout.rb'
 require 'stripe_mock/request_handlers/checkout_session.rb'
 require 'stripe_mock/instance'
 
@@ -90,12 +90,14 @@ require 'stripe_mock/test_strategies/live.rb'
 module StripeMock
 
   @default_currency = 'usd'
+  @checkout_base = "https://checkout.stripe.com/pay/"
   lib_dir = File.expand_path(File.dirname(__FILE__), '../..')
   @webhook_fixture_path = './spec/fixtures/stripe_webhooks/'
   @webhook_fixture_fallback_path = File.join(lib_dir, 'stripe_mock/webhook_fixtures')
 
   class << self
     attr_accessor :default_currency
+    attr_accessor :checkout_base
     attr_accessor :webhook_fixture_path
   end
 end

data/spec/instance_spec.rb

@@ -6,7 +6,9 @@ describe StripeMock::Instance do
   let(:stripe_helper) { StripeMock.create_test_helper }
 
   it_behaves_like_stripe do
-    def test_data_source(type); StripeMock.instance.send(type); end
+    def test_data_source(type)
+      StripeMock.instance.send(type)
+    end
   end
 
   before { StripeMock.start }

data/spec/integration_examples/completing_checkout_sessions_example.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+shared_examples "Completing Checkout Sessions" do
+  let(:test_helper) { StripeMock.create_test_helper }
+  before { StripeMock.start }
+  after { StripeMock.stop }
+
+  it "can complete payment checkout sessions" do
+    session = test_helper.create_checkout_session(mode: "payment")
+    payment_method = Stripe::PaymentMethod.create(type: "card")
+
+    payment_intent = test_helper.complete_checkout_session(session, payment_method)
+
+    expect(payment_intent.id).to eq(session.payment_intent)
+    expect(payment_intent.payment_method).to eq(payment_method.id)
+    expect(payment_intent.status).to eq("succeeded")
+  end
+
+  it "can complete setup checkout sessions" do
+    session = test_helper.create_checkout_session(mode: "setup")
+    payment_method = Stripe::PaymentMethod.create(type: "card")
+
+    setup_intent = test_helper.complete_checkout_session(session, payment_method)
+
+    expect(setup_intent.id).to eq(session.setup_intent)
+    expect(setup_intent.payment_method).to eq(payment_method.id)
+  end
+
+  it "can complete subscription checkout sessions" do
+    session = test_helper.create_checkout_session(mode: "subscription")
+    payment_method = Stripe::PaymentMethod.create(type: "card")
+
+    subscription = test_helper.complete_checkout_session(session, payment_method)
+
+    expect(subscription.default_payment_method).to eq(payment_method.id)
+  end
+end

data/spec/readme_spec.rb

@@ -47,7 +47,7 @@ describe 'README examples' do
 
     customer_object = event.data.object
     expect(customer_object.id).to_not be_nil
-    expect(customer_object.default_card).to_not be_nil
+    expect(customer_object.default_source).to_not be_nil
     # etc.
   end
 

data/spec/shared_stripe_examples/account_examples.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 shared_examples 'Account API' do
-  describe 'retrive accounts' do
+  describe 'retrieve accounts' do
     it 'retrieves a stripe account', live: true do
       account = Stripe::Account.retrieve
 
@@ -86,6 +86,14 @@ shared_examples 'Account API' do
     end
   end
 
+  describe 'delete account' do
+    it 'deletes a stripe account' do
+      account = Stripe::Account.create(email: 'test@test.com')
+      account = account.delete
+      expect(account.deleted).to eq(true)
+    end
+  end
+
   it 'deauthorizes the stripe account', live: false do
     account = Stripe::Account.retrieve
     result = account.deauthorize('CLIENT_ID')

data/spec/shared_stripe_examples/checkout_session_examples.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+shared_examples "Checkout Session API" do
+  it "creates PaymentIntent with payment mode" do
+    line_items = [{
+      name: "T-shirt",
+      quantity: 2,
+      amount: 500,
+      currency: "usd",
+    }]
+    session = Stripe::Checkout::Session.create(
+      payment_method_types: ["card"],
+      line_items: line_items,
+      cancel_url: "https://example.com/cancel",
+      success_url: "https://example.com/success"
+    )
+
+    expect(session.payment_intent).to_not be_empty
+    payment_intent = Stripe::PaymentIntent.retrieve(session.payment_intent)
+    expect(payment_intent.amount).to eq(1000)
+    expect(payment_intent.currency).to eq("usd")
+    expect(payment_intent.customer).to eq(session.customer)
+  end
+
+  context "when creating a payment" do
+    it "requires line_items" do
+      expect do
+        session = Stripe::Checkout::Session.create(
+          customer: "customer_id",
+          success_url: "localhost/nada",
+          cancel_url: "localhost/nada",
+          payment_method_types: ["card"],
+        )
+      end.to raise_error(Stripe::InvalidRequestError, /line_items/i)
+
+    end
+  end
+
+  it "creates SetupIntent with setup mode" do
+    session = Stripe::Checkout::Session.create(
+      mode: "setup",
+      payment_method_types: ["card"],
+      cancel_url: "https://example.com/cancel",
+      success_url: "https://example.com/success"
+    )
+
+    expect(session.setup_intent).to_not be_empty
+    setup_intent = Stripe::SetupIntent.retrieve(session.setup_intent)
+    expect(setup_intent.payment_method_types).to eq(["card"])
+  end
+
+  context "when creating a subscription" do
+    it "requires line_items" do
+      expect do
+        session = Stripe::Checkout::Session.create(
+          customer: "customer_id",
+          success_url: "localhost/nada",
+          cancel_url: "localhost/nada",
+          payment_method_types: ["card"],
+          mode: "subscription",
+        )
+      end.to raise_error(Stripe::InvalidRequestError, /line_items/i)
+
+    end
+  end
+
+  context "retrieve a checkout session" do
+    let(:checkout_session1) { stripe_helper.create_checkout_session }
+
+    it "can be retrieved by id" do
+      checkout_session1
+
+      checkout_session = Stripe::Checkout::Session.retrieve(checkout_session1.id)
+
+      expect(checkout_session.id).to eq(checkout_session1.id)
+    end
+
+    it "cannot retrieve a checkout session that doesn't exist" do
+      expect { Stripe::Checkout::Session.retrieve("nope") }.to raise_error { |e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.param).to eq("checkout_session")
+        expect(e.http_status).to eq(404)
+      }
+    end
+
+    it "can expand setup_intent" do
+      initial_session = Stripe::Checkout::Session.create(
+        mode: "setup",
+        cancel_url: "https://example.com",
+        success_url: "https://example.com",
+        payment_method_types: ["card"]
+      )
+
+      checkout_session = Stripe::Checkout::Session.retrieve(id: initial_session.id, expand: ["setup_intent"])
+
+      expect(checkout_session.setup_intent).to be_a_kind_of(Stripe::SetupIntent)
+    end
+  end
+end

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -14,6 +14,11 @@ shared_examples 'Invoice API' do
       expect(data[invoice.id]).to_not be_nil
       expect(data[invoice.id][:id]).to eq(invoice.id)
     end
+
+    it "supports invoice number" do
+      original = Stripe::Invoice.create
+      expect(original.number).to be
+    end
   end
 
   context "retrieving an invoice" do
@@ -83,12 +88,28 @@ shared_examples 'Invoice API' do
       @invoice = @invoice.pay
       expect(@invoice.attempted).to eq(true)
       expect(@invoice.paid).to eq(true)
+      expect(@invoice.status).to eq("paid")
     end
 
     it 'creates a new charge object' do
       expect{ @invoice.pay }.to change { Stripe::Charge.list.data.count }.by 1
     end
 
+    it 'should work with Stripe::Invoice.pay(invoice_id)' do
+      expect(@invoice.paid).to_not eq(true)
+
+      expect {
+        Stripe::Invoice.pay(@invoice.id)
+      }.to change { Stripe::Charge.list.data.count }.by 1
+
+      @invoice = Stripe::Invoice.retrieve(id: @invoice.id)
+      expect(@invoice).to_not be_nil
+
+      expect(@invoice.attempted).to eq(true)
+      expect(@invoice.paid).to eq(true)
+      expect(@invoice.status).to eq("paid")
+    end
+
     it 'sets the charge attribute' do
       @invoice = @invoice.pay
       expect(@invoice.charge).to be_a String

data/spec/shared_stripe_examples/payment_intent_examples.rb

@@ -2,6 +2,11 @@ require 'spec_helper'
 
 shared_examples 'PaymentIntent API' do
 
+  let(:customer) do
+    token = Stripe::Token.retrieve(stripe_helper.generate_card_token(number: '4242424242424242'))
+    Stripe::Customer.create(email: 'alice@bob.com', source: token.id)
+  end
+
   it "creates a succeeded stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount:  100, currency: "usd")
 
@@ -92,6 +97,35 @@ shared_examples 'PaymentIntent API' do
     expect(Stripe::BalanceTransaction.retrieve(balance_txn).id).to eq(balance_txn)
   end
 
+  it 'creates a charge for a stripe payment_intent with confirm flag to true' do
+    payment_intent = Stripe::PaymentIntent.create amount: 100,
+                                                  currency: 'usd',
+                                                  confirm: true,
+                                                  customer: customer,
+                                                  payment_method: customer.sources.first
+
+    charge = payment_intent.charges.data.first
+    expect(charge.amount).to eq(payment_intent.amount)
+    expect(charge.payment_intent).to eq(payment_intent.id)
+    expect(charge.description).to be_nil
+
+    charge.description = 'Updated description'
+    charge.save
+
+    updated = Stripe::Charge.retrieve(charge.id)
+    expect(updated.description).to eq('Updated description')
+  end
+
+  it "includes the payment_method on charges" do
+    payment_intent = Stripe::PaymentIntent.create(
+      amount: 100, currency: "usd", confirm: true, payment_method: "test_pm_1"
+    )
+    expect(payment_intent.status).to eq("succeeded")
+    expect(payment_intent.charges.data.size).to eq(1)
+    expect(payment_intent.charges.data.first.object).to eq("charge")
+    expect(payment_intent.charges.data.first.payment_method).to eq("test_pm_1")
+  end
+
   it "confirms a stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
     confirmed_payment_intent = payment_intent.confirm()
@@ -100,6 +134,25 @@ shared_examples 'PaymentIntent API' do
     expect(confirmed_payment_intent.charges.data.first.object).to eq('charge')
   end
 
+  it 'creates a charge for a confirmed stripe payment_intent' do
+    payment_intent = Stripe::PaymentIntent.create amount: 100,
+                                                  currency: 'usd',
+                                                  customer: customer,
+                                                  payment_method: customer.sources.first
+
+    confirmed_payment_intent = payment_intent.confirm
+    charge = confirmed_payment_intent.charges.data.first
+    expect(charge.amount).to eq(confirmed_payment_intent.amount)
+    expect(charge.payment_intent).to eq(confirmed_payment_intent.id)
+    expect(charge.description).to be_nil
+
+    charge.description = 'Updated description'
+    charge.save
+
+    updated = Stripe::Charge.retrieve(charge.id)
+    expect(updated.description).to eq('Updated description')
+  end
+
   it "captures a stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
     confirmed_payment_intent = payment_intent.capture()
@@ -108,6 +161,27 @@ shared_examples 'PaymentIntent API' do
     expect(confirmed_payment_intent.charges.data.first.object).to eq('charge')
   end
 
+  it 'creates a charge for a captured stripe payment_intent' do
+    payment_intent = Stripe::PaymentIntent.create amount: 3055,
+                                                  currency: 'usd',
+                                                  customer: customer,
+                                                  payment_method: customer.sources.first,
+                                                  confirm: true,
+                                                  capture_method: 'manual'
+
+    captured_payment_intent = payment_intent.capture
+    charge = captured_payment_intent.charges.data.first
+    expect(charge.amount).to eq(captured_payment_intent.amount)
+    expect(charge.payment_intent).to eq(captured_payment_intent.id)
+    expect(charge.description).to be_nil
+
+    charge.description = 'Updated description'
+    charge.save
+
+    updated = Stripe::Charge.retrieve(charge.id)
+    expect(updated.description).to eq('Updated description')
+  end
+
   it "cancels a stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
     confirmed_payment_intent = payment_intent.cancel()