stripe-ruby-mock 3.1.0.rc3 → 4.0.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

@@ -42,6 +42,7 @@ require 'stripe_mock/request_handlers/helpers/external_account_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/card_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/charge_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/coupon_helpers.rb'
+require 'stripe_mock/request_handlers/helpers/search_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/subscription_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/token_helpers.rb'
 
@@ -65,6 +66,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 +81,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 +91,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/bank_token_examples.rb

@@ -28,20 +28,19 @@ shared_examples 'Bank Account Token Mocking' do
     expect(bank_token).to match /^test_btok/
   end
 
-  it "assigns the generated bank account to a new recipient" do
+  it "assigns the generated bank account to a new customer" do
     bank_token = StripeMock.generate_bank_token(
       :bank_name => "Bank Token Mocking",
       :last4 => "7777"
     )
 
-    recipient = Stripe::Recipient.create({
+    customer = Stripe::Customer.create({
       name: "Fred Flinstone",
-      type: "individual",
       email: 'blah@domain.co',
-      bank_account: bank_token
+      source: bank_token
     })
-    expect(recipient.active_account.last4).to eq("7777")
-    expect(recipient.active_account.bank_name).to eq("Bank Token Mocking")
+    expect(customer.sources.first.last4).to eq("7777")
+    expect(customer.sources.first.bank_name).to eq("Bank Token Mocking")
   end
 
   it "retrieves a created token" do
@@ -55,5 +54,4 @@ shared_examples 'Bank Account Token Mocking' do
     expect(token.bank_account.last4).to eq("3939")
     expect(token.bank_account.bank_name).to eq("Cha-ching Banking")
   end
-
 end

data/spec/shared_stripe_examples/charge_examples.rb

@@ -494,4 +494,101 @@ shared_examples 'Charge API' do
     end
   end
 
+  context "search" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches charges for exact matches", :aggregate_failures do
+      response = Stripe::Charge.search({query: 'amount:100'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+      one = Stripe::Charge.create(
+        customer: customer.id,
+        amount: 100,
+        currency: "usd",
+        payment_method_details: {
+          card: StripeMock::Data.mock_charge[:payment_method_details][:card].merge(
+            brand: "mastercard",
+            exp_month: 1,
+            exp_year: 2111,
+            fingerprint: "un",
+            last4: "1111",
+          ),
+        },
+        status: "succeeded",
+        metadata: {key: 'uno'},
+      )
+      two = Stripe::Charge.create(
+        customer: customer.id,
+        amount: 200,
+        currency: "gbp",
+        payment_method_details: {
+          card: StripeMock::Data.mock_charge[:payment_method_details][:card].merge(
+            brand: "visa",
+            exp_month: 2,
+            exp_year: 2222,
+            fingerprint: "deux",
+            last4: "2222",
+          ),
+        },
+        status: "pending",
+        metadata: {key: 'dos'},
+      )
+
+      response = Stripe::Charge.search({query: 'amount:100'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'currency:"gbp"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Charge.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.brand:mastercard'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.exp_month:2'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.exp_year:2111'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.fingerprint:un'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.last4:2222'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Charge.search({query: 'status:"succeeded"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'metadata["key"]:"uno"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+    end
+
+    it "respects limit", :aggregate_failures do
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+      11.times do
+        Stripe::Charge.create(customer: customer.id, amount: 100, currency: "usd")
+      end
+
+      response = Stripe::Charge.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Charge.search({query: %(customer:"#{customer.id}"), limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Charge.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Charge.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Charge.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `charges`./)
+    end
+  end
 end

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