epopia-stripe-ruby-mock 2.5.8

data/spec/readme_spec.rb

@@ -0,0 +1,75 @@
+require 'stripe_mock'
+
+describe 'README examples' do
+  let(:stripe_helper) { StripeMock.create_test_helper }
+
+  before { StripeMock.start }
+  after  { StripeMock.stop }
+
+  it "creates a stripe customer" do
+
+    # This doesn't touch stripe's servers nor the internet!
+    customer = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      card: stripe_helper.generate_card_token
+    })
+    expect(customer.email).to eq('johnny@appleseed.com')
+  end
+
+
+  it "mocks a declined card error" do
+    # Prepares an error for the next create charge request
+    StripeMock.prepare_card_error(:card_declined)
+
+    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('card_declined')
+      expect(e.json_body[:error][:decline_code]).to eq('do_not_honor')
+    }
+  end
+
+  it "has built-in card errors" do
+    StripeMock.prepare_card_error(:incorrect_number)
+    StripeMock.prepare_card_error(:invalid_number)
+    StripeMock.prepare_card_error(:invalid_expiry_month)
+    StripeMock.prepare_card_error(:invalid_expiry_year)
+    StripeMock.prepare_card_error(:invalid_cvc)
+    StripeMock.prepare_card_error(:expired_card)
+    StripeMock.prepare_card_error(:incorrect_cvc)
+    StripeMock.prepare_card_error(:card_declined)
+    StripeMock.prepare_card_error(:missing)
+    StripeMock.prepare_card_error(:processing_error)
+  end
+
+  it "mocks a stripe webhook" do
+    event = StripeMock.mock_webhook_event('customer.created')
+
+    customer_object = event.data.object
+    expect(customer_object.id).to_not be_nil
+    expect(customer_object.default_card).to_not be_nil
+    # etc.
+  end
+
+  it "can override default webhook values" do
+    event = StripeMock.mock_webhook_event('customer.created', {
+      :id => 'cus_my_custom_value',
+      :email => 'joe@example.com'
+    })
+    # Alternatively:
+    # event.data.object.id = 'cus_my_custom_value'
+    # event.data.object.email = 'joe@example.com'
+    expect(event.data.object.id).to eq('cus_my_custom_value')
+    expect(event.data.object.email).to eq('joe@example.com')
+  end
+
+  it "generates a stripe card token" do
+    card_token = StripeMock.generate_card_token(last4: "9191", exp_year: 1984)
+
+    cus = Stripe::Customer.create(source: card_token)
+    card = cus.sources.data.first
+    expect(card.last4).to eq("9191")
+    expect(card.exp_year).to eq(1984)
+  end
+
+end

data/spec/server_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require_stripe_examples
+
+describe 'StripeMock Server', :mock_server => true do
+
+  let(:stripe_helper) { StripeMock.create_test_helper }
+
+  it_behaves_like_stripe do
+    def test_data_source(type); StripeMock.client.get_server_data(type); end
+  end
+
+  before(:all) do
+    StripeMock.spawn_server
+  end
+
+  before do
+    @client = StripeMock.start_client
+  end
+
+  after { StripeMock.stop_client(:clear_server_data => true) }
+
+
+  it "uses an RPC client for mock requests" do
+    charge = Stripe::Charge.create(
+      amount: 987,
+      currency: 'USD',
+      source: stripe_helper.generate_card_token,
+      description: 'card charge'
+    )
+    expect(charge.amount).to eq(987)
+    expect(charge.currency).to eq('USD')
+    expect(charge.description).to eq('card charge')
+  end
+
+
+  it "should not clear server data in between client sessions by default" do
+    customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+    expect(customer.email).to eq('johnny@appleseed.com')
+
+    server_customer_data = StripeMock.client.get_server_data(:customers)[customer.id]
+    expect(server_customer_data).to_not be_nil
+    expect(server_customer_data[:email]).to eq('johnny@appleseed.com')
+
+    StripeMock.stop_client
+    StripeMock.start_client
+
+    server_customer_data = StripeMock.client.get_server_data(:customers)[customer.id]
+    expect(server_customer_data).to_not be_nil
+    expect(server_customer_data[:email]).to eq('johnny@appleseed.com')
+  end
+
+
+  it "returns a response with symbolized hash keys" do
+    stripe_helper.create_plan(id: 'x')
+    response, api_key = StripeMock.redirect_to_mock_server('get', '/v1/plans/x', api_key: 'xxx')
+    response.data.keys.each {|k| expect(k).to be_a(Symbol) }
+  end
+
+
+  it "can toggle debug" do
+    StripeMock.toggle_debug(true)
+    expect(@client.server_debug?).to eq(true)
+    StripeMock.toggle_debug(false)
+    expect(@client.server_debug?).to eq(false)
+  end
+
+
+  it "should toggle off debug when mock session ends" do
+    StripeMock.toggle_debug(true)
+
+    StripeMock.stop_client
+    expect(StripeMock.client).to be_nil
+
+    StripeMock.start_client
+    expect(StripeMock.client.server_debug?).to eq(false)
+  end
+
+
+  it "can set the default server pid path" do
+    expect(StripeMock.default_server_pid_path).to eq('./stripe-mock-server.pid')
+
+    orig = StripeMock.default_server_pid_path
+    StripeMock.default_server_pid_path = 'abc'
+    expect(StripeMock.default_server_pid_path).to eq('abc')
+
+    # Set back to original for #kill_server to work properly
+    StripeMock.default_server_pid_path = orig
+  end
+
+  it "can set the default server log path" do
+    expect(StripeMock.default_server_log_path).to eq('./stripe-mock-server.log')
+
+    StripeMock.default_server_log_path = 'yule.log'
+    expect(StripeMock.default_server_log_path).to eq('yule.log')
+  end
+
+
+  it "doesn't create multiple clients" do
+    result = StripeMock.start_client
+    expect(result.__id__).to eq(@client.__id__)
+  end
+
+
+  it "raises an error when client is stopped" do
+    expect(@client).to be_a StripeMock::Client
+    expect(@client.state).to eq('ready')
+
+    StripeMock.stop_client
+    expect(@client.state).to eq('closed')
+    expect { @client.clear_server_data }.to raise_error StripeMock::ClosedClientConnectionError
+  end
+
+
+  it "raises an error when client connection is closed" do
+    expect(@client).to be_a StripeMock::Client
+    expect(@client.state).to eq('ready')
+
+    @client.close!
+    expect(@client.state).to eq('closed')
+    expect(StripeMock.stop_client).to eq(false)
+  end
+
+
+  it "throws an error when server is not running" do
+    StripeMock.stop_client
+    begin
+      StripeMock.start_client(1515)
+      # We should never get here
+      expect(false).to eq(true)
+    rescue StripeMock::ServerTimeoutError => e
+      expect(e).to be_a StripeMock::ServerTimeoutError
+    end
+  end
+
+  it "can set a conversion rate" do
+    StripeMock.set_conversion_rate(1.2)
+    expect(StripeMock.client.get_conversion_rate).to eq(1.2)
+  end
+end

data/spec/shared_stripe_examples/account_examples.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+shared_examples 'Account API' do
+  describe 'retrive accounts' do
+    it 'retrieves a stripe account', live: true do
+      account = Stripe::Account.retrieve
+
+      expect(account).to be_a Stripe::Account
+      expect(account.id).to match /acct\_/
+    end
+    it 'retrieves a specific stripe account' do
+      account = Stripe::Account.retrieve('acct_103ED82ePvKYlo2C')
+
+      expect(account).to be_a Stripe::Account
+      expect(account.id).to match /acct\_/
+    end
+    it 'retrieves all' do
+      accounts = Stripe::Account.all
+
+      expect(accounts).to be_a Stripe::ListObject
+      expect(accounts.data.count).to satisfy { |n| n >= 1 }
+    end
+  end
+  describe 'create account' do
+    it 'creates one more account' do
+      account = Stripe::Account.create(email: 'lol@what.com')
+
+      expect(account).to be_a Stripe::Account
+    end
+    it 'create managed account' do
+      account = Stripe::Account.create(managed: true, country: 'CA')
+
+      # expect(account).to include(:keys)
+      expect(account.keys).not_to be_nil
+      expect(account.keys.secret).to match /sk_(live|test)_[\d\w]+/
+      expect(account.keys.publishable).to match /pk_(live|test)_[\d\w]+/
+      expect(account.external_accounts).not_to be_nil
+      expect(account.external_accounts.data).to be_an Array
+      expect(account.external_accounts.url).to match /\/v1\/accounts\/.*\/external_accounts/
+    end
+  end
+  describe 'updates account' do
+    it 'updates account' do
+      account = Stripe::Account.retrieve
+      account.support_phone = '1234567'
+      account.save
+
+      account = Stripe::Account.retrieve
+
+      expect(account.support_phone).to eq '1234567'
+    end
+
+    it 'raises when sending an empty tos date' do
+      account = Stripe::Account.retrieve
+      account.tos_acceptance.date = nil
+      expect {
+        account.save
+      }.to raise_error
+    end
+
+    context 'with tos acceptance date' do
+      let(:error_message) { "ToS acceptance date is not valid. Dates are expected to be integers, measured in seconds, not in the future, and after 2009" }
+
+      it 'raises error when tos date is before 2009' do
+        date = Date.new(2008,1,1).strftime("%s").to_i
+
+        account = Stripe::Account.retrieve
+        account.tos_acceptance.date = date
+
+        expect {
+          account.save
+        }.to raise_error Stripe::InvalidRequestError, error_message
+      end
+
+      it 'raises error when tos date is in the future' do
+        year = Time.now.year + 5
+        date = Date.new(year,1,1).strftime("%s").to_i
+
+        account = Stripe::Account.retrieve
+        account.tos_acceptance.date = date
+
+        expect {
+          account.save
+        }.to raise_error Stripe::InvalidRequestError, error_message
+      end
+    end
+  end
+
+  it 'deauthorizes the stripe account', live: false do
+    account = Stripe::Account.retrieve
+    result = account.deauthorize('CLIENT_ID')
+
+    expect(result).to be_a Stripe::StripeObject
+    expect(result[:stripe_user_id]).to eq account[:id]
+  end
+end

data/spec/shared_stripe_examples/balance_examples.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+shared_examples 'Balance API' do
+
+  it "retrieves a stripe balance" do
+    StripeMock.set_account_balance(2000)
+    balance = Stripe::Balance.retrieve()
+    expect(balance.available[0].amount).to eq(2000)
+  end
+
+end

data/spec/shared_stripe_examples/balance_transaction_examples.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+shared_examples 'Balance Transaction API' do
+
+  let(:stripe_helper) { StripeMock.create_test_helper }
+
+  it "returns an error if balance transaction does not exist" do
+    txn_id = 'txn_xxxxxxxxxxxxxxxxxxxxxxxx'
+
+    expect {
+      Stripe::BalanceTransaction.retrieve(txn_id)
+    }.to raise_error { |e|
+      expect(e).to be_a(Stripe::InvalidRequestError)
+      expect(e.message).to eq('No such balance_transaction: ' + txn_id)
+    }
+  end
+
+  it "retrieves a single balance transaction" do
+    txn_id = 'txn_05RsQX2eZvKYlo2C0FRTGSSA'
+    txn = Stripe::BalanceTransaction.retrieve(txn_id)
+
+    expect(txn).to be_a(Stripe::BalanceTransaction)
+    expect(txn.id).to eq(txn_id)
+  end
+
+  describe "listing balance transactions" do
+
+    it "retrieves all balance transactions" do
+      disputes = Stripe::BalanceTransaction.all
+
+      expect(disputes.count).to eq(10)
+      expect(disputes.map &:id).to include('txn_05RsQX2eZvKYlo2C0FRTGSSA','txn_15RsQX2eZvKYlo2C0ERTYUIA', 'txn_25RsQX2eZvKYlo2C0ZXCVBNM', 'txn_35RsQX2eZvKYlo2C0QAZXSWE', 'txn_45RsQX2eZvKYlo2C0EDCVFRT', 'txn_55RsQX2eZvKYlo2C0OIKLJUY', 'txn_65RsQX2eZvKYlo2C0ASDFGHJ', 'txn_75RsQX2eZvKYlo2C0EDCXSWQ', 'txn_85RsQX2eZvKYlo2C0UJMCDET', 'txn_95RsQX2eZvKYlo2C0EDFRYUI')
+    end
+
+  end
+
+  it 'retrieves balance transactions for an automated transfer' do
+    transfer_id = Stripe::Transfer.create({ amount: 2730, currency: "usd" })
+
+    # verify transfer currently has no balance transactions
+    transfer_transactions = Stripe::BalanceTransaction.all({transfer: transfer_id})
+    expect(transfer_transactions.count).to eq(0)
+
+    # verify we can create a new balance transaction associated with the transfer
+    new_txn_id = stripe_helper.upsert_stripe_object(:balance_transaction, {amount: 12300, transfer: transfer_id})
+    new_txn = Stripe::BalanceTransaction.retrieve(new_txn_id)
+    expect(new_txn).to be_a(Stripe::BalanceTransaction)
+    expect(new_txn.amount).to eq(12300)
+    # although transfer was specified as an attribute on the balance_transaction, it should not be returned in the object
+    expect{new_txn.transfer}.to raise_error(NoMethodError)
+
+    # verify we can update an existing balance transaction to associate with the transfer
+    existing_txn_id = 'txn_05RsQX2eZvKYlo2C0FRTGSSA'
+    existing_txn = Stripe::BalanceTransaction.retrieve(existing_txn_id)
+    stripe_helper.upsert_stripe_object(:balance_transaction, {id: existing_txn_id, transfer: transfer_id})
+
+    # now verify that only these balance transactions are retrieved with the transfer
+    transfer_transactions = Stripe::BalanceTransaction.all({transfer: transfer_id})
+    expect(transfer_transactions.count).to eq(2)
+    expect(transfer_transactions.map &:id).to include(new_txn_id, existing_txn_id)
+  end
+
+end

data/spec/shared_stripe_examples/bank_examples.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+shared_examples 'Bank API' do
+
+  it 'creates/returns a bank when using customer.sources.create given a bank token' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    bank = customer.sources.create(source: bank_token)
+
+    expect(bank.customer).to eq('test_customer_sub')
+    expect(bank.last4).to eq("1123")
+    expect(bank.exp_month).to eq(11)
+    expect(bank.exp_year).to eq(2099)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.sources.count).to eq(1)
+    bank = customer.sources.data.first
+    expect(bank.customer).to eq('test_customer_sub')
+    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 customer.sources.create given bank params' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    bank = customer.sources.create(bank: {
+      number: '4242424242424242',
+      exp_month: '11',
+      exp_year: '3031',
+      cvc: '123'
+    })
+
+    expect(bank.customer).to eq('test_customer_sub')
+    expect(bank.last4).to eq("6789")
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.sources.count).to eq(1)
+    bank = customer.sources.data.first
+    expect(bank.customer).to eq('test_customer_sub')
+    expect(bank.last4).to eq("6789")
+  end
+
+  it "creates a single bank with a generated bank token" do
+    customer = Stripe::Customer.create
+    expect(customer.sources.count).to eq 0
+
+    customer.sources.create :source => stripe_helper.generate_bank_token
+    # Yes, stripe-ruby does not actually add the new bank to the customer instance
+    expect(customer.sources.count).to eq 0
+
+    customer2 = Stripe::Customer.retrieve(customer.id)
+    expect(customer2.sources.count).to eq 1
+    expect(customer2.default_source).to eq customer2.sources.first.id
+  end
+
+  it 'create does not change the customers default bank if already set' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub', default_source: "test_cc_original")
+    bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    bank = customer.sources.create(source: bank_token)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.default_source).to eq("test_cc_original")
+  end
+
+  it 'create updates the customers default bank if not set' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    bank = customer.sources.create(source: bank_token)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.default_source).to_not be_nil
+  end
+
+  describe "retrieval and deletion with customers" do
+    let!(:customer) { Stripe::Customer.create(id: 'test_customer_sub') }
+    let!(:bank_token) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:bank) { customer.sources.create(source: bank_token) }
+
+    it "can retrieve all customer's banks" do
+      retrieved = customer.sources.all
+      expect(retrieved.count).to eq(1)
+    end
+
+    it "retrieves a customers bank" do
+      retrieved = customer.sources.retrieve(bank.id)
+      expect(retrieved.to_s).to eq(bank.to_s)
+    end
+
+    it "retrieves a customer's bank after re-fetching the customer" do
+      retrieved = Stripe::Customer.retrieve(customer.id).sources.retrieve(bank.id)
+      expect(retrieved.id).to eq bank.id
+    end
+
+    it "deletes a customers bank" do
+      bank.delete
+      retrieved_cus = Stripe::Customer.retrieve(customer.id)
+      expect(retrieved_cus.sources.data).to be_empty
+    end
+
+    it "deletes a customers bank then set the default_bank to nil" do
+      bank.delete
+      retrieved_cus = Stripe::Customer.retrieve(customer.id)
+      expect(retrieved_cus.default_source).to be_nil
+    end
+
+    it "updates the default bank if deleted" do
+      bank.delete
+      retrieved_cus = Stripe::Customer.retrieve(customer.id)
+      expect(retrieved_cus.default_source).to be_nil
+    end
+
+    context "deletion when the user has two banks" do
+      let!(:bank_token_2) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+      let!(:bank_2) { customer.sources.create(source: bank_token_2) }
+
+      it "has just one bank anymore" do
+        bank.delete
+        retrieved_cus = Stripe::Customer.retrieve(customer.id)
+        expect(retrieved_cus.sources.data.count).to eq 1
+        expect(retrieved_cus.sources.data.first.id).to eq bank_2.id
+      end
+
+      it "sets the default_bank id to the last bank remaining id" do
+        bank.delete
+        retrieved_cus = Stripe::Customer.retrieve(customer.id)
+        expect(retrieved_cus.default_source).to eq bank_2.id
+      end
+    end
+  end
+
+  describe "Errors", :live => true do
+    it "throws an error when the customer does not have the retrieving bank id" do
+      customer = Stripe::Customer.create
+      bank_id = "bank_123"
+      expect { customer.sources.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!(:customer) { Stripe::Customer.create(id: 'test_customer_sub') }
+    let!(:bank_token) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:bank) { customer.sources.create(source: 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 = customer.sources.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
+      customer = Stripe::Customer.create(id: 'test_customer_bank')
+
+      bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+      bank1 = customer.sources.create(source: bank_token)
+      bank_token = stripe_helper.generate_bank_token(last4: "1124", exp_month: 12, exp_year: 2098)
+      bank2 = customer.sources.create(source: bank_token)
+
+      customer = Stripe::Customer.retrieve('test_customer_bank')
+
+      list = customer.sources.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::Customer.create(id: 'no_banks')
+      customer = Stripe::Customer.retrieve('no_banks')
+
+      list = customer.sources.all
+
+      expect(list.object).to eq("list")
+      expect(list.count).to eq(0)
+      expect(list.data.length).to eq(0)
+    end
+  end
+
+  describe 'Stripe::Token creation from bank account' do
+    it 'generates token from bank account informations' do
+      token = Stripe::Token.create({
+        bank_account: {
+          account_number: "4222222222222222",
+          routing_number: "123456",
+          bank_name: "Fake bank"
+        }
+      })
+
+      cus = Stripe::Customer.create(source: token.id)
+      bank_account = cus.sources.data.first
+      expect(bank_account.bank_name).to eq('Fake bank')
+    end
+
+    it 'generates token from existing bank account token' do
+      bank_token = StripeMock.generate_bank_token(bank_name: 'Fake bank')
+      cus = Stripe::Customer.create(source: bank_token)
+      token = Stripe::Token.create({ customer: cus.id, bank_account: cus.sources.first.id })
+      cus.sources.create(source: token.id)
+      cus = Stripe::Customer.retrieve(cus.id)
+      expect(cus.sources.data.count).to eq 2
+      cus.sources.data.each do |source|
+        expect(source.bank_name).to eq('Fake bank')
+      end
+    end
+  end
+end