stripe-ruby-mock 2.4.0 → 2.5.8

data/spec/shared_stripe_examples/card_examples.rb

@@ -21,7 +21,7 @@ shared_examples 'Card API' do
     expect(card.exp_year).to eq(2099)
   end
 
-  it 'creates/returns a card when using recipient.cards.create given a card token' do
+  it 'creates/returns a card when using recipient.cards.create given a card token', skip: 'Stripe has deprecated Recipients' do
     params = {
       id: 'test_recipient_sub',
       name: 'MyRec',
@@ -69,7 +69,7 @@ shared_examples 'Card API' do
     expect(card.exp_year).to eq(3031)
   end
 
-  it 'creates/returns a card when using recipient.cards.create given card params' do
+  it 'creates/returns a card when using recipient.cards.create given card params', skip: 'Stripe has deprecated Recipients' do
     params = {
       id: 'test_recipient_sub',
       name: 'MyRec',
@@ -166,6 +166,13 @@ shared_examples 'Card API' do
       expect(retrieved_cus.default_source).to be_nil
     end
 
+    it 'updates total_count if deleted' do
+      card.delete
+      sources = Stripe::Customer.retrieve(customer.id).sources
+
+      expect(sources.total_count).to eq 0
+    end
+
     context "deletion when the user has two cards" do
       let!(:card_token_2) { stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099) }
       let!(:card_2) { customer.sources.create(source: card_token_2) }
@@ -185,7 +192,7 @@ shared_examples 'Card API' do
     end
   end
 
-  describe "retrieval and deletion with recipients", :live => true do
+  describe "retrieval and deletion with recipients", :live => true, skip: 'Stripe has deprecated Recipients' do
     let!(:recipient) { Stripe::Recipient.create(name: 'Test Recipient', type: 'individual') }
     let!(:card_token) { stripe_helper.generate_card_token(number: "4000056655665556") }
     let!(:card) { recipient.cards.create(card: card_token) }

data/spec/shared_stripe_examples/charge_examples.rb

@@ -163,18 +163,38 @@ shared_examples 'Charge API' do
   end
 
   it "creates a balance transaction" do
+    amount = 300
+    fee = 10
     charge = Stripe::Charge.create({
-      amount: 300,
+      amount: amount,
       currency: 'USD',
-      source: stripe_helper.generate_card_token
+      source: stripe_helper.generate_card_token,
+      application_fee: fee,
     })
     bal_trans = Stripe::BalanceTransaction.retrieve(charge.balance_transaction)
-    expect(bal_trans.amount).to eq(charge.amount)
-    expect(bal_trans.fee).to eq(39)
-    expect(bal_trans.source).to eq(charge.source)
+    expect(bal_trans.amount).to eq(amount)
+    expect(bal_trans.fee).to eq(39 + fee)
+    expect(bal_trans.source).to eq(charge.id)
+    expect(bal_trans.net).to eq(amount - bal_trans.fee)
   end
 
-  it "can expand balance transaction" do
+  context 'when conversion rate is set' do
+    it "balance transaction stores amount converted from charge currency to USD" do
+      StripeMock.set_conversion_rate(1.2)
+
+      charge = Stripe::Charge.create({
+        amount: 300,
+        currency: 'CAD',
+        source: stripe_helper.generate_card_token
+      })
+      bal_trans = Stripe::BalanceTransaction.retrieve(charge.balance_transaction)
+      expect(bal_trans.amount).to eq(charge.amount * 1.2)
+      expect(bal_trans.fee).to eq(39)
+      expect(bal_trans.currency).to eq('usd')
+    end
+  end
+
+  it "can expand balance transaction when creating a charge" do
     charge = Stripe::Charge.create({
       amount: 300,
       currency: 'USD',
@@ -196,6 +216,20 @@ shared_examples 'Charge API' do
     expect(charge.amount).to eq(original.amount)
   end
 
+  it "can expand balance transaction when retrieving a charge" do
+    original = Stripe::Charge.create({
+      amount: 300,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token
+    })
+    charge = Stripe::Charge.retrieve(
+      id: original.id,
+      expand: ['balance_transaction']
+    )
+
+    expect(charge.balance_transaction).to be_a(Stripe::BalanceTransaction)
+  end
+
   it "cannot retrieve a charge that doesn't exist" do
     expect { Stripe::Charge.retrieve('nope') }.to raise_error {|e|
       expect(e).to be_a Stripe::InvalidRequestError
@@ -227,6 +261,23 @@ shared_examples 'Charge API' do
     expect(updated.fraud_details.to_hash).to eq(charge.fraud_details.to_hash)
   end
 
+  it "updates a stripe charge with no changes" do
+    original = Stripe::Charge.create({
+      amount: 777,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token,
+      description: 'Original description',
+      destination: {
+        account: "acct_SOMEBOGUSID",
+        amount: 150
+      }
+    })
+
+    expect {
+      updated = original.save
+    }.not_to raise_error
+  end
+
   it "marks a charge as safe" do
     original = Stripe::Charge.create({
       amount: 777,
@@ -310,7 +361,7 @@ shared_examples 'Charge API' do
     end
 
     it "stores all charges in memory" do
-      expect(Stripe::Charge.all.data.map(&:id)).to eq([@charge.id, @charge2.id])
+      expect(Stripe::Charge.all.data.map(&:id).reverse).to eq([@charge.id, @charge2.id])
     end
 
     it "defaults count to 10 charges" do
@@ -425,29 +476,34 @@ shared_examples 'Charge API' do
 
   describe "idempotency" do
     let(:customer) { Stripe::Customer.create(email: 'johnny@appleseed.com') }
-    let(:idempotent_charge_params) {{
+    let(:charge_params) {{
       amount: 777,
       currency: 'USD',
       customer: customer.id,
-      capture: true,
+      capture: true
+    }}
+    let(:charge_headers) {{
       idempotency_key: 'onceisenough'
     }}
 
     it "returns the original charge if the same idempotency_key is passed in" do
-      charge1 = Stripe::Charge.create(idempotent_charge_params)
-      charge2 = Stripe::Charge.create(idempotent_charge_params)
+      charge1 = Stripe::Charge.create(charge_params, charge_headers)
+      charge2 = Stripe::Charge.create(charge_params, charge_headers)
 
       expect(charge1).to eq(charge2)
     end
 
-    it "returns different charges if different idempotency_keys are used for each charge" do
-      idempotent_charge_params2 = idempotent_charge_params.clone
-      idempotent_charge_params2[:idempotency_key] = 'thisoneisdifferent'
+    context 'different key' do
+      let(:different_charge_headers) {{
+        idempotency_key: 'thisoneisdifferent'
+      }}
 
-      charge1 = Stripe::Charge.create(idempotent_charge_params)
-      charge2 = Stripe::Charge.create(idempotent_charge_params2)
+      it "returns different charges if different idempotency_keys are used for each charge" do
+        charge1 = Stripe::Charge.create(charge_params, charge_headers)
+        charge2 = Stripe::Charge.create(charge_params, different_charge_headers)
 
-      expect(charge1).not_to eq(charge2)
+        expect(charge1).not_to eq(charge2)
+      end
     end
   end
 

data/spec/shared_stripe_examples/coupon_examples.rb

@@ -27,6 +27,12 @@ shared_examples 'Coupon API' do
                  expect(e.message).to match /duration/
              }
     end
+    it 'fails when a coupon is created without a currency when amount_off is specified' do
+      expect { Stripe::Coupon.create(id: '10OFF', duration: 'once', amount_off: 1000) }.to raise_error {|e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.message).to match /You must pass currency when passing amount_off/
+      }
+    end
   end
 
   context 'retrieve coupon', live: true do
@@ -56,7 +62,7 @@ shared_examples 'Coupon API' do
     it "cannot retrieve a stripe coupon that doesn't exist" do
       expect { Stripe::Coupon.retrieve('nope') }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
-        expect(e.param).to eq('id')
+        expect(e.param).to eq('coupon')
         expect(e.http_status).to eq(404)
       }
     end
@@ -71,7 +77,7 @@ shared_examples 'Coupon API' do
 
       expect { Stripe::Coupon.retrieve(coupon.id) }.to raise_error {|e|
         expect(e).to be_a Stripe::InvalidRequestError
-        expect(e.param).to eq('id')
+        expect(e.param).to eq('coupon')
         expect(e.http_status).to eq(404)
       }
     end

data/spec/shared_stripe_examples/customer_examples.rb

@@ -78,6 +78,15 @@ shared_examples 'Customer API' do
     expect(customer.sources.data.first.exp_year).to eq 2024
   end
 
+  it 'creates a customer with name' do
+    customer = Stripe::Customer.create(
+      source: gen_card_tk,
+      name: 'John Appleseed'
+    )
+    expect(customer.id).to match(/^test_cus/)
+    expect(customer.name).to eq('John Appleseed')
+  end
+
   it 'creates a customer with a plan' do
     plan = stripe_helper.create_plan(id: 'silver')
     customer = Stripe::Customer.create(id: 'test_cus_plan', source: gen_card_tk, :plan => 'silver')
@@ -215,6 +224,21 @@ shared_examples 'Customer API' do
     customer = Stripe::Customer.retrieve('test_cus_coupon')
     expect(customer.discount).to_not be_nil
     expect(customer.discount.coupon).to_not be_nil
+    expect(customer.discount.customer).to eq customer.id
+    expect(customer.discount.start).to be_within(1).of Time.now.to_i
+  end
+
+  describe 'repeating coupon with duration limit', live: true do
+    let!(:coupon) { stripe_helper.create_coupon(id: '10OFF', amount_off: 1000, currency: 'usd', duration: 'repeating', duration_in_months: 12) }
+    let!(:customer) { Stripe::Customer.create(coupon: coupon.id) }
+    it 'creates the discount with the end date', live: true do
+      discount = Stripe::Customer.retrieve(customer.id).discount
+      expect(discount).to_not be_nil
+      expect(discount.coupon).to_not be_nil
+      expect(discount.end).to be_within(1).of (Time.now.to_datetime >> 12).to_time.to_i
+    end
+    after { Stripe::Coupon.retrieve(coupon.id).delete }
+    after { Stripe::Customer.retrieve(customer.id).delete }
   end
 
   it 'cannot create a customer with a coupon that does not exist' do
@@ -252,11 +276,25 @@ shared_examples 'Customer API' do
 
     expect(customer.id).to eq(original.id)
     expect(customer.email).to eq(original.email)
+    expect(customer.name).to eq(nil)
     expect(customer.default_source).to eq(original.default_source)
+    expect(customer.default_source).not_to be_a(Stripe::Card)
     expect(customer.subscriptions.count).to eq(0)
     expect(customer.subscriptions.data).to be_empty
   end
 
+  it "can expand default_source" do
+    original = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      source: gen_card_tk
+    })
+    customer = Stripe::Customer.retrieve(
+      id: original.id,
+      expand: ['default_source']
+    )
+    expect(customer.default_source).to be_a(Stripe::Card)
+  end
+
   it "cannot retrieve a customer that doesn't exist" do
     expect { Stripe::Customer.retrieve('nope') }.to raise_error {|e|
       expect(e).to be_a Stripe::InvalidRequestError
@@ -378,7 +416,7 @@ shared_examples 'Customer API' do
     customer = customer.delete
     expect(customer.deleted).to eq(true)
   end
-  
+
   it 'works with the update_subscription method' do
     stripe_helper.create_plan(id: 'silver')
     cus   = Stripe::Customer.create(source: gen_card_tk)
@@ -386,5 +424,19 @@ shared_examples 'Customer API' do
       cus.update_subscription(plan: 'silver')
     }.not_to raise_error
   end
-  
+
+  it "deletes a stripe customer discount" do
+    original = Stripe::Customer.create(id: 'test_customer_update')
+
+    coupon = Stripe::Coupon.create(id: "10PERCENT", duration: 'once')
+    original.coupon = coupon.id
+    original.save
+
+    expect(original.discount.coupon).to be_a Stripe::Coupon
+
+    original.delete_discount
+
+    customer = Stripe::Customer.retrieve("test_customer_update")
+    expect(customer.discount).to be nil
+  end
 end

data/spec/shared_stripe_examples/dispute_examples.rb

@@ -3,6 +3,8 @@ require 'pp'
 
 shared_examples 'Dispute API' do
 
+  let(:stripe_helper) { StripeMock.create_test_helper }
+
   it "returns an error if dispute does not exist" do
     dispute_id = 'dp_xxxxxxxxxxxxxxxxxxxxxxxx'
 
@@ -18,7 +20,7 @@ shared_examples 'Dispute API' do
     dispute_id = 'dp_05RsQX2eZvKYlo2C0FRTGSSA'
     dispute = Stripe::Dispute.retrieve(dispute_id)
 
-    expect(dispute).to be_a(Stripe::Dispute) 
+    expect(dispute).to be_a(Stripe::Dispute)
     expect(dispute.id).to eq(dispute_id)
   end
 
@@ -36,7 +38,7 @@ shared_examples 'Dispute API' do
       :customer_name => 'Rebel Idealist',
       :product_description => 'Lorem ipsum dolor sit amet.',
       :shipping_documentation => 'fil_15BZxW2eZvKYlo2CvQbrn9dc',
-    }    
+    }
     dispute.save
 
     dispute = Stripe::Dispute.retrieve(dispute_id)
@@ -50,13 +52,13 @@ shared_examples 'Dispute API' do
 
   it "closes a dispute" do
     dispute_id = 'dp_75RsQX2eZvKYlo2C0EDCXSWQ'
-    
+
     dispute = Stripe::Dispute.retrieve(dispute_id)
-    
+
     expect(dispute).to be_a(Stripe::Dispute)
     expect(dispute.id).to eq(dispute_id)
     expect(dispute.status).to eq('under_review')
-    
+
     dispute.close
 
     dispute = Stripe::Dispute.retrieve(dispute_id)
@@ -67,7 +69,7 @@ shared_examples 'Dispute API' do
   end
 
   describe "listing disputes" do
-    
+
     it "retrieves all disputes" do
       disputes = Stripe::Dispute.all
 
@@ -79,9 +81,18 @@ shared_examples 'Dispute API' do
       disputes = Stripe::Dispute.all(limit: 3)
 
       expect(disputes.count).to eq(3)
-      expect(disputes.map &:id).to include('dp_05RsQX2eZvKYlo2C0FRTGSSA','dp_15RsQX2eZvKYlo2C0ERTYUIA', 'dp_25RsQX2eZvKYlo2C0ZXCVBNM')
+      expected = ['dp_95RsQX2eZvKYlo2C0EDFRYUI','dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ']
+      expect(disputes.map &:id).to include(*expected)
     end
 
   end
-  
+
+  it "creates a dispute" do
+    card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    charge = Stripe::Charge.create(amount: 1000, currency: "usd", source: card_token)
+    stripe_dispute_id = stripe_helper.upsert_stripe_object(:dispute, {amount: charge.amount, charge: charge.id})
+    stripe_dispute = Stripe::Dispute.retrieve(stripe_dispute_id)
+    expect(stripe_dispute.charge).to eq(charge.id)
+  end
+
 end

data/spec/shared_stripe_examples/ephemeral_key_examples.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+shared_examples 'EphemeralKey API' do
+  describe 'Create a new key' do
+    let(:customer)  { Stripe::Customer.create email: 'test@example.com' }
+    let(:version) { '2016-07-06' }
+
+    it 'creates a new key' do
+      key = Stripe::EphemeralKey.create(
+        { customer: customer.id },
+        { stripe_version: version }
+      )
+
+      expect(key[:associated_objects][0][:id]).to eq customer.id
+    end
+  end
+end

data/spec/shared_stripe_examples/error_mock_examples.rb

@@ -12,7 +12,7 @@ end
 shared_examples 'Stripe Error Mocking' do
 
   it "mocks a manually given stripe card error" do
-    error = Stripe::CardError.new('Test Msg', 'param_name', 'bad_code', 444, 'body', 'json body')
+    error = Stripe::CardError.new('Test Msg', 'param_name', 'bad_code', http_status: 444, http_body: 'body', json_body: 'json body')
     StripeMock.prepare_error(error)
 
     expect { Stripe::Customer.create() }.to raise_error {|e|
@@ -30,7 +30,7 @@ shared_examples 'Stripe Error Mocking' do
 
   it "mocks a manually gives stripe invalid request error" do
 
-    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', 987, 'ibody', 'json ibody')
+    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', http_status: 987, http_body: 'ibody', json_body: 'json ibody')
     StripeMock.prepare_error(error)
 
     expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to raise_error {|e|
@@ -46,7 +46,7 @@ shared_examples 'Stripe Error Mocking' do
 
 
   it "mocks a manually gives stripe invalid auth error" do
-    error = Stripe::AuthenticationError.new('Bad Auth', 499, 'abody', 'json abody')
+    error = Stripe::AuthenticationError.new('Bad Auth', http_status: 499, http_body: 'abody', json_body: 'json abody')
     StripeMock.prepare_error(error)
 
     expect { stripe_helper.create_plan() }.to raise_error {|e|

data/spec/shared_stripe_examples/external_account_examples.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+shared_examples 'External Account API' do
+
+  it 'creates/returns a bank when using account.external_accounts.create given a bank token' do
+    account = Stripe::Account.create(id: 'test_account', type: 'custom', country: "US")
+    bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    bank = account.external_accounts.create(external_account: bank_token)
+
+    expect(bank.account).to eq('test_account')
+    expect(bank.last4).to eq("1123")
+    expect(bank.exp_month).to eq(11)
+    expect(bank.exp_year).to eq(2099)
+
+    account = Stripe::Account.retrieve('test_account')
+    expect(account.external_accounts.count).to eq(1)
+    bank = account.external_accounts.first
+    expect(bank.account).to eq('test_account')
+    expect(bank.last4).to eq("1123")
+    expect(bank.exp_month).to eq(11)
+    expect(bank.exp_year).to eq(2099)
+  end
+
+  it 'creates/returns a bank when using account.external_accounts.create given bank params' do
+    account = Stripe::Account.create(id: 'test_account', type: 'custom', country: "US")
+    bank = account.external_accounts.create(external_account: {
+                                              object: 'bank_account',
+                                              account_number: '000123456789',
+                                              routing_number: '110000000',
+                                              country: 'US',
+                                              currency: 'usd'
+                                            })
+
+    expect(bank.account).to eq('test_account')
+    expect(bank.routing_number).to eq('110000000')
+    expect(bank.country).to eq('US')
+    expect(bank.currency).to eq('usd')
+
+    account = Stripe::Account.retrieve('test_account')
+    expect(account.external_accounts.count).to eq(1)
+    bank = account.external_accounts.first
+    expect(bank.account).to eq('test_account')
+    expect(bank.routing_number).to eq('110000000')
+    expect(bank.country).to eq('US')
+    expect(bank.currency).to eq('usd')
+  end
+
+  it "creates a single bank with a generated bank token" do
+    account = Stripe::Account.create(type: 'custom', country: "US")
+    expect(account.external_accounts.count).to eq 0
+
+    account.external_accounts.create external_account: stripe_helper.generate_bank_token
+    # Yes, stripe-ruby does not actually add the new bank to the account instance
+    expect(account.external_accounts.count).to eq 0
+
+    account2 = Stripe::Account.retrieve(account.id)
+    expect(account2.external_accounts.count).to eq 1
+  end
+
+  describe "retrieval and deletion with accounts" do
+    let!(:account) { Stripe::Account.create(id: 'test_account', type: 'custom', country: "US") }
+    let!(:bank_token) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:bank) { account.external_accounts.create(external_account: bank_token) }
+
+    it "can retrieve all account's banks" do
+      retrieved = account.external_accounts.all
+      expect(retrieved.count).to eq(1)
+    end
+
+    it "retrieves an account bank" do
+      retrieved = account.external_accounts.retrieve(bank.id)
+      expect(retrieved.to_s).to eq(bank.to_s)
+    end
+
+    it "retrieves an account's bank after re-fetching the account" do
+      retrieved = Stripe::Account.retrieve(account.id).external_accounts.retrieve(bank.id)
+      expect(retrieved.id).to eq bank.id
+    end
+
+    it "deletes an accounts bank" do
+      bank.delete
+      retrieved_acct = Stripe::Account.retrieve(account.id)
+      expect(retrieved_acct.external_accounts.data).to be_empty
+    end
+
+    context "deletion when the user has two external accounts" do
+      let!(:bank_token_2) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+      let!(:bank_2) { account.external_accounts.create(external_account: bank_token_2) }
+
+      it "has just one bank anymore" do
+        bank.delete
+        retrieved_acct = Stripe::Account.retrieve(account.id)
+        expect(retrieved_acct.external_accounts.data.count).to eq 1
+        expect(retrieved_acct.external_accounts.data.first.id).to eq bank_2.id
+      end
+    end
+  end
+
+  describe "Errors" do
+    it "throws an error when the account does not have the retrieving bank id" do
+      account = Stripe::Account.create(type: 'custom', country: "US")
+      bank_id = "bank_123"
+      expect { account.external_accounts.retrieve(bank_id) }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.message).to match /no.*source/i
+        expect(e.message).to include bank_id
+        expect(e.param).to eq 'id'
+        expect(e.http_status).to eq 404
+      }
+    end
+  end
+
+  context "update bank" do
+    let!(:account) { Stripe::Account.create(id: 'test_account', type: 'custom', country: "US") }
+    let!(:bank_token) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:bank) { account.external_accounts.create(external_account: bank_token) }
+
+    it "updates the bank" do
+      exp_month = 10
+      exp_year = 2098
+
+      bank.exp_month = exp_month
+      bank.exp_year = exp_year
+      bank.save
+
+      retrieved = account.external_accounts.retrieve(bank.id)
+
+      expect(retrieved.exp_month).to eq(exp_month)
+      expect(retrieved.exp_year).to eq(exp_year)
+    end
+  end
+
+  context "retrieve multiple banks" do
+
+    it "retrieves a list of multiple banks" do
+      account = Stripe::Account.create(id: 'test_account', type: 'custom', country: "US")
+
+      bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+      bank1 = account.external_accounts.create(external_accout: bank_token)
+      bank_token = stripe_helper.generate_bank_token(last4: "1124", exp_month: 12, exp_year: 2098)
+      bank2 = account.external_accounts.create(external_account: bank_token)
+
+      account = Stripe::Account.retrieve('test_account')
+
+      list = account.external_accounts.all
+
+      expect(list.object).to eq("list")
+      expect(list.count).to eq(2)
+      expect(list.data.length).to eq(2)
+
+      expect(list.data.first.object).to eq("bank_account")
+      expect(list.data.first.to_hash).to eq(bank1.to_hash)
+
+      expect(list.data.last.object).to eq("bank_account")
+      expect(list.data.last.to_hash).to eq(bank2.to_hash)
+    end
+
+    it "retrieves an empty list if there's no subscriptions" do
+      Stripe::Account.create(id: 'no_banks', type: 'custom', country: "US")
+      account = Stripe::Account.retrieve('no_banks')
+
+      list = account.external_accounts.all
+
+      expect(list.object).to eq("list")
+      expect(list.count).to eq(0)
+      expect(list.data.length).to eq(0)
+    end
+  end
+
+end

data/spec/shared_stripe_examples/extra_features_examples.rb

@@ -8,6 +8,7 @@ shared_examples 'Extra Features' do
 
     customer = Stripe::Customer.create
     expect(customer.id).to match /^custom_prefix_cus/
+    StripeMock.global_id_prefix = nil
   end
 
   it "can set the global id prefix to nothing" do
@@ -23,6 +24,7 @@ shared_examples 'Extra Features' do
 
     customer = Stripe::Customer.create
     expect(customer.id).to match /^cus/
+    StripeMock.global_id_prefix = nil
   end
 
   it "has a default global id prefix" do