epopia-stripe-ruby-mock 2.5.8

data/spec/shared_stripe_examples/dispute_examples.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+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'
+
+    expect {
+      Stripe::Dispute.retrieve(dispute_id)
+    }.to raise_error { |e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.message).to eq('No such dispute: ' + dispute_id)
+    }
+  end
+
+  it "retrieves a single dispute" do
+    dispute_id = 'dp_05RsQX2eZvKYlo2C0FRTGSSA'
+    dispute = Stripe::Dispute.retrieve(dispute_id)
+
+    expect(dispute).to be_a(Stripe::Dispute)
+    expect(dispute.id).to eq(dispute_id)
+  end
+
+  it "updates a dispute" do
+    dispute_id = 'dp_65RsQX2eZvKYlo2C0ASDFGHJ'
+    dispute = Stripe::Dispute.retrieve(dispute_id)
+
+    expect(dispute).to be_a(Stripe::Dispute)
+    expect(dispute.id).to eq(dispute_id)
+    expect(dispute.evidence.customer_name).to eq(nil)
+    expect(dispute.evidence.product_description).to eq(nil)
+    expect(dispute.evidence.shipping_documentation).to eq(nil)
+
+    dispute.evidence = {
+      :customer_name => 'Rebel Idealist',
+      :product_description => 'Lorem ipsum dolor sit amet.',
+      :shipping_documentation => 'fil_15BZxW2eZvKYlo2CvQbrn9dc',
+    }
+    dispute.save
+
+    dispute = Stripe::Dispute.retrieve(dispute_id)
+
+    expect(dispute).to be_a(Stripe::Dispute)
+    expect(dispute.id).to eq(dispute_id)
+    expect(dispute.evidence.customer_name).to eq('Rebel Idealist')
+    expect(dispute.evidence.product_description).to eq('Lorem ipsum dolor sit amet.')
+    expect(dispute.evidence.shipping_documentation).to eq('fil_15BZxW2eZvKYlo2CvQbrn9dc')
+  end
+
+  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)
+
+    expect(dispute).to be_a(Stripe::Dispute)
+    expect(dispute.id).to eq(dispute_id)
+    expect(dispute.status).to eq('lost')
+  end
+
+  describe "listing disputes" do
+
+    it "retrieves all disputes" do
+      disputes = Stripe::Dispute.all
+
+      expect(disputes.count).to eq(10)
+      expect(disputes.map &:id).to include('dp_05RsQX2eZvKYlo2C0FRTGSSA','dp_15RsQX2eZvKYlo2C0ERTYUIA', 'dp_25RsQX2eZvKYlo2C0ZXCVBNM', 'dp_35RsQX2eZvKYlo2C0QAZXSWE', 'dp_45RsQX2eZvKYlo2C0EDCVFRT', 'dp_55RsQX2eZvKYlo2C0OIKLJUY', 'dp_65RsQX2eZvKYlo2C0ASDFGHJ', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ', 'dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_95RsQX2eZvKYlo2C0EDFRYUI')
+    end
+
+    it "retrieves disputes with a limit(3)" do
+      disputes = Stripe::Dispute.all(limit: 3)
+
+      expect(disputes.count).to eq(3)
+      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

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+def expect_card_error(code, param)
+  expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to raise_error {|e|
+    expect(e).to be_a(Stripe::CardError)
+    expect(e.http_status).to eq(402)
+    expect(e.code).to eq(code)
+    expect(e.param).to eq(param)
+  }
+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', http_status: 444, http_body: 'body', json_body: 'json body')
+    StripeMock.prepare_error(error)
+
+    expect { Stripe::Customer.create() }.to raise_error {|e|
+      expect(e).to be_a(Stripe::CardError)
+      expect(e.code).to eq('bad_code')
+      expect(e.param).to eq('param_name')
+      expect(e.message).to eq('Test Msg')
+
+      expect(e.http_status).to eq(444)
+      expect(e.http_body).to eq('body')
+      expect(e.json_body).to eq('json body')
+    }
+  end
+
+
+  it "mocks a manually gives stripe invalid request error" do
+
+    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|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.param).to eq('param')
+      expect(e.message).to eq('Test Invalid')
+
+      expect(e.http_status).to eq(987)
+      expect(e.http_body).to eq('ibody')
+      expect(e.json_body).to eq('json ibody')
+    }
+  end
+
+
+  it "mocks a manually gives stripe invalid auth error" do
+    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|
+      expect(e).to be_a(Stripe::AuthenticationError)
+      expect(e.message).to eq('Bad Auth')
+
+      expect(e.http_status).to eq(499)
+      expect(e.http_body).to eq('abody')
+      expect(e.json_body).to eq('json abody')
+    }
+  end
+
+
+  it "raises a custom error for specific actions" do
+    custom_error = StandardError.new("Please knock first.")
+    StripeMock.prepare_error(custom_error, :new_customer)
+
+    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.")
+    }
+  end
+
+  # # # # # # # # # # # # # #
+  # Card Error Helper Methods
+  # # # # # # # # # # # # # #
+
+  it "raises an error for an unrecognized card error code" do
+    expect { StripeMock.prepare_card_error(:non_existant_error_code) }.to raise_error {|e|
+      expect(e).to be_a(StripeMock::StripeMockError)
+    }
+  end
+
+  it "only raises a card error when a card charge is attempted" do
+    StripeMock.prepare_card_error(:card_declined)
+    expect { Stripe::Customer.create(id: 'x') }.to_not raise_error
+    expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to raise_error Stripe::CardError
+  end
+
+  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', 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)
+      expect(e.http_status).to eq(402)
+      expect(e.code).to eq('incorrect_cvc')
+      expect(e.param).to eq('cvc')
+    }
+  end
+
+  it "mocks an incorrect number card error" do
+    StripeMock.prepare_card_error(:incorrect_number)
+    expect_card_error 'incorrect_number', 'number'
+  end
+
+  it "mocks an invalid number card error" do
+    StripeMock.prepare_card_error(:invalid_number)
+    expect_card_error 'invalid_number', 'number'
+  end
+
+  it "mocks an invalid expiration month card error" do
+    StripeMock.prepare_card_error(:invalid_expiry_month)
+    expect_card_error 'invalid_expiry_month', 'exp_month'
+  end
+
+  it "mocks an invalid expiration year card error" do
+    StripeMock.prepare_card_error(:invalid_expiry_year)
+    expect_card_error 'invalid_expiry_year', 'exp_year'
+  end
+
+  it "mocks an invalid cvc card error" do
+    StripeMock.prepare_card_error(:invalid_cvc)
+    expect_card_error 'invalid_cvc', 'cvc'
+  end
+
+  it "mocks an expired card error" do
+    StripeMock.prepare_card_error(:expired_card)
+    expect_card_error 'expired_card', 'exp_month'
+  end
+
+  it "mocks an incorrect cvc card error" do
+    StripeMock.prepare_card_error(:incorrect_cvc)
+    expect_card_error 'incorrect_cvc', 'cvc'
+  end
+
+  it "mocks a declined card error" do
+    StripeMock.prepare_card_error(:card_declined)
+    expect_card_error 'card_declined', nil
+  end
+
+  it "mocks a missing card error" do
+    StripeMock.prepare_card_error(:missing)
+    expect_card_error 'missing', nil
+  end
+
+  it "mocks a processing error card error" do
+    StripeMock.prepare_card_error(:processing_error)
+    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