stripe-ruby-mock 2.3.1 → 2.5.8

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|
@@ -64,7 +64,10 @@ shared_examples 'Stripe Error Mocking' do
     custom_error = StandardError.new("Please knock first.")
     StripeMock.prepare_error(custom_error, :new_customer)
 
-    expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to_not raise_error
+    expect {
+      Stripe::Charge.create(amount: 1, currency: 'usd', source: stripe_helper.generate_card_token)
+    }.to_not raise_error
+
     expect { Stripe::Customer.create }.to raise_error {|e|
       expect(e).to be_a StandardError
       expect(e.message).to eq("Please knock first.")
@@ -89,7 +92,9 @@ shared_examples 'Stripe Error Mocking' do
 
   it "mocks a card error with a given handler" do
     StripeMock.prepare_card_error(:incorrect_cvc, :new_customer)
-    expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to_not raise_error
+    expect {
+      Stripe::Charge.create(amount: 1, currency: 'usd', source: stripe_helper.generate_card_token)
+    }.to_not raise_error
 
     expect { Stripe::Customer.create() }.to raise_error {|e|
       expect(e).to be_a(Stripe::CardError)
@@ -149,4 +154,9 @@ shared_examples 'Stripe Error Mocking' do
     expect_card_error 'processing_error', nil
   end
 
+  it "mocks an incorrect zip code card error" do
+    StripeMock.prepare_card_error(:incorrect_zip)
+    expect_card_error 'incorrect_zip', 'address_zip'
+  end
+
 end

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