epopia-stripe-ruby-mock 2.5.8

data/spec/shared_stripe_examples/bank_token_examples.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+shared_examples 'Bank Account Token Mocking' do
+
+  it "generates a bank token with default values" do
+    bank_token = StripeMock.generate_bank_token
+    tokens = test_data_source(:bank_tokens)
+    expect(tokens[bank_token]).to_not be_nil
+    expect(tokens[bank_token][:bank_name]).to eq("STRIPEMOCK TEST BANK")
+    expect(tokens[bank_token][:last4]).to eq("6789")
+  end
+
+  it "generates a bank token with an associated account in memory" do
+    bank_token = StripeMock.generate_bank_token(
+      :bank_name => "Memory Bank",
+      :last4 => "7171"
+    )
+    tokens = test_data_source(:bank_tokens)
+    expect(tokens[bank_token]).to_not be_nil
+    expect(tokens[bank_token][:bank_name]).to eq("Memory Bank")
+    expect(tokens[bank_token][:last4]).to eq("7171")
+  end
+
+  it "creates a token whose id begins with test_btok" do
+    bank_token = StripeMock.generate_bank_token({
+      :last4 => "1212"
+    })
+    expect(bank_token).to match /^test_btok/
+  end
+
+  it "assigns the generated bank account to a new recipient" do
+    bank_token = StripeMock.generate_bank_token(
+      :bank_name => "Bank Token Mocking",
+      :last4 => "7777"
+    )
+
+    recipient = Stripe::Recipient.create({
+      name: "Fred Flinstone",
+      type: "individual",
+      email: 'blah@domain.co',
+      bank_account: bank_token
+    })
+    expect(recipient.active_account.last4).to eq("7777")
+    expect(recipient.active_account.bank_name).to eq("Bank Token Mocking")
+  end
+
+  it "retrieves a created token" do
+    bank_token = StripeMock.generate_bank_token(
+      :bank_name => "Cha-ching Banking",
+      :last4 => "3939"
+    )
+    token = Stripe::Token.retrieve(bank_token)
+
+    expect(token.id).to eq(bank_token)
+    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/card_examples.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+
+shared_examples 'Card API' do
+
+  it 'creates/returns a card when using customer.sources.create given a card token' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    card = customer.sources.create(source: card_token)
+
+    expect(card.customer).to eq('test_customer_sub')
+    expect(card.last4).to eq("1123")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(2099)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.sources.count).to eq(1)
+    card = customer.sources.data.first
+    expect(card.customer).to eq('test_customer_sub')
+    expect(card.last4).to eq("1123")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(2099)
+  end
+
+  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',
+      type: 'individual'
+    }
+
+    recipient = Stripe::Recipient.create(params)
+    card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    card = recipient.cards.create(card: card_token)
+
+    expect(card.recipient).to eq('test_recipient_sub')
+    expect(card.last4).to eq("1123")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(2099)
+
+    recipient = Stripe::Recipient.retrieve('test_recipient_sub')
+    expect(recipient.cards.count).to eq(1)
+    card = recipient.cards.data.first
+    expect(card.recipient).to eq('test_recipient_sub')
+    expect(card.last4).to eq("1123")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(2099)
+  end
+
+  it 'creates/returns a card when using customer.sources.create given card params' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    card = customer.sources.create(card: {
+      number: '4242424242424242',
+      exp_month: '11',
+      exp_year: '3031',
+      cvc: '123'
+    })
+
+    expect(card.customer).to eq('test_customer_sub')
+    expect(card.last4).to eq("4242")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(3031)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.sources.count).to eq(1)
+    card = customer.sources.data.first
+    expect(card.customer).to eq('test_customer_sub')
+    expect(card.last4).to eq("4242")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(3031)
+  end
+
+  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',
+      type: 'individual'
+    }
+    recipient = Stripe::Recipient.create(params)
+    card = recipient.cards.create(card: {
+      number: '4000056655665556',
+      exp_month: '11',
+      exp_year: '3031',
+      cvc: '123'
+    })
+
+    expect(card.recipient).to eq('test_recipient_sub')
+    expect(card.last4).to eq("5556")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(3031)
+
+    recipient = Stripe::Recipient.retrieve('test_recipient_sub')
+    expect(recipient.cards.count).to eq(1)
+    card = recipient.cards.data.first
+    expect(card.recipient).to eq('test_recipient_sub')
+    expect(card.last4).to eq("5556")
+    expect(card.exp_month).to eq(11)
+    expect(card.exp_year).to eq(3031)
+  end
+
+  it "creates a single card with a generated card token", :live => true do
+    customer = Stripe::Customer.create
+    expect(customer.sources.count).to eq 0
+
+    customer.sources.create :source => stripe_helper.generate_card_token
+    # Yes, stripe-ruby does not actually add the new card 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 card if already set' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub', default_source: "test_cc_original")
+    card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    card = customer.sources.create(source: card_token)
+
+    customer = Stripe::Customer.retrieve('test_customer_sub')
+    expect(customer.default_source).to eq("test_cc_original")
+  end
+
+  it 'create updates the customers default card if not set' do
+    customer = Stripe::Customer.create(id: 'test_customer_sub')
+    card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    card = customer.sources.create(source: card_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!(:card_token) { stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:card) { customer.sources.create(source: card_token) }
+
+    it "can retrieve all customer's cards" do
+      retrieved = customer.sources.all
+      expect(retrieved.count).to eq(1)
+    end
+
+    it "retrieves a customers card" do
+      retrieved = customer.sources.retrieve(card.id)
+      expect(retrieved.to_s).to eq(card.to_s)
+    end
+
+    it "retrieves a customer's card after re-fetching the customer" do
+      retrieved = Stripe::Customer.retrieve(customer.id).sources.retrieve(card.id)
+      expect(retrieved.id).to eq card.id
+    end
+
+    it "deletes a customers card" do
+      card.delete
+      retrieved_cus = Stripe::Customer.retrieve(customer.id)
+      expect(retrieved_cus.sources.data).to be_empty
+    end
+
+    it "deletes a customers card then set the default_card to nil" do
+      card.delete
+      retrieved_cus = Stripe::Customer.retrieve(customer.id)
+      expect(retrieved_cus.default_source).to be_nil
+    end
+
+    it "updates the default card if deleted" do
+      card.delete
+      retrieved_cus = Stripe::Customer.retrieve(customer.id)
+      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) }
+
+      it "has just one card anymore" do
+        card.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 card_2.id
+      end
+
+      it "sets the default_card id to the last card remaining id" do
+        card.delete
+        retrieved_cus = Stripe::Customer.retrieve(customer.id)
+        expect(retrieved_cus.default_source).to eq card_2.id
+      end
+    end
+  end
+
+  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) }
+
+    it "can retrieve all recipient's cards" do
+      retrieved = recipient.cards.all
+      expect(retrieved.count).to eq(1)
+    end
+
+    it "deletes a recipient card" do
+      card.delete
+      retrieved_cus = Stripe::Recipient.retrieve(recipient.id)
+      expect(retrieved_cus.cards.data).to be_empty
+    end
+
+    it "deletes a recipient card then set the default_card to nil" do
+      card.delete
+      retrieved_cus = Stripe::Recipient.retrieve(recipient.id)
+      expect(retrieved_cus.default_card).to be_nil
+    end
+
+    context "deletion when the recipient has two cards" do
+      let!(:card_token_2) {  stripe_helper.generate_card_token(number: "5200828282828210") }
+      let!(:card_2) { recipient.cards.create(card: card_token_2) }
+
+      it "has just one card anymore" do
+        card.delete
+        retrieved_rec = Stripe::Recipient.retrieve(recipient.id)
+        expect(retrieved_rec.cards.data.count).to eq 1
+        expect(retrieved_rec.cards.data.first.id).to eq card_2.id
+      end
+
+      it "sets the default_card id to the last card remaining id" do
+        card.delete
+        retrieved_rec = Stripe::Recipient.retrieve(recipient.id)
+        expect(retrieved_rec.default_card).to eq card_2.id
+      end
+    end
+  end
+
+  describe "Errors", :live => true do
+    it "throws an error when the customer does not have the retrieving card id" do
+      customer = Stripe::Customer.create
+      card_id = "card_123"
+      expect { customer.sources.retrieve(card_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 card_id
+        expect(e.param).to eq 'id'
+        expect(e.http_status).to eq 404
+      }
+    end
+  end
+
+  context "update card" do
+    let!(:customer) { Stripe::Customer.create(id: 'test_customer_sub') }
+    let!(:card_token) { stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:card) { customer.sources.create(source: card_token) }
+
+    it "updates the card" do
+      exp_month = 10
+      exp_year = 2098
+
+      card.exp_month = exp_month
+      card.exp_year = exp_year
+      card.save
+
+      retrieved = customer.sources.retrieve(card.id)
+
+      expect(retrieved.exp_month).to eq(exp_month)
+      expect(retrieved.exp_year).to eq(exp_year)
+    end
+  end
+
+  context "retrieve multiple cards" do
+
+    it "retrieves a list of multiple cards" do
+      customer = Stripe::Customer.create(id: 'test_customer_card')
+
+      card_token = stripe_helper.generate_card_token(last4: "1123", exp_month: 11, exp_year: 2099)
+      card1 = customer.sources.create(source: card_token)
+      card_token = stripe_helper.generate_card_token(last4: "1124", exp_month: 12, exp_year: 2098)
+      card2 = customer.sources.create(source: card_token)
+
+      customer = Stripe::Customer.retrieve('test_customer_card')
+
+      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("card")
+      expect(list.data.first.to_hash).to eq(card1.to_hash)
+
+      expect(list.data.last.object).to eq("card")
+      expect(list.data.last.to_hash).to eq(card2.to_hash)
+    end
+
+    it "retrieves an empty list if there's no subscriptions" do
+      Stripe::Customer.create(id: 'no_cards')
+      customer = Stripe::Customer.retrieve('no_cards')
+
+      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
+
+end

data/spec/shared_stripe_examples/card_token_examples.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+shared_examples 'Card Token Mocking' do
+
+  describe 'Direct Token Creation' do
+
+    it "generates and reads a card token with default values" do
+      card_token = StripeMock.generate_card_token
+
+      charge = Stripe::Charge.create(amount: 500, currency: 'usd', source: card_token)
+      card = charge.source
+      expect(card.last4).to eq("4242")
+      expect(card.exp_month).to eq(4)
+      expect(card.exp_year).to eq(2016)
+      expect(card.tokenization_method).to eq(nil)
+    end
+
+    it "generates and reads a card token for create charge" do
+      card_token = StripeMock.generate_card_token(last4: "2244", exp_month: 33, exp_year: 2255)
+
+      charge = Stripe::Charge.create(amount: 500, currency: 'usd', source: card_token)
+      card = charge.source
+      expect(card.last4).to eq("2244")
+      expect(card.exp_month).to eq(33)
+      expect(card.exp_year).to eq(2255)
+    end
+
+    it "generates and reads a card token for create customer" do
+      card_token = StripeMock.generate_card_token(last4: "9191", exp_month: 99, exp_year: 3005)
+
+      cus = Stripe::Customer.create(source: card_token)
+      card = cus.sources.data.first
+      expect(card.last4).to eq("9191")
+      expect(card.exp_month).to eq(99)
+      expect(card.exp_year).to eq(3005)
+    end
+
+    it "generates and reads a card token for update customer" do
+      card_token = StripeMock.generate_card_token(last4: "1133", exp_month: 11, exp_year: 2099)
+
+      cus = Stripe::Customer.create
+      cus.source = card_token
+      cus.save
+
+      card = cus.sources.data.first
+      expect(card.last4).to eq("1133")
+      expect(card.exp_month).to eq(11)
+      expect(card.exp_year).to eq(2099)
+    end
+
+    it "retrieves a created token" do
+      card_token = StripeMock.generate_card_token(last4: "2323", exp_month: 33, exp_year: 2222)
+      token = Stripe::Token.retrieve(card_token)
+
+      expect(token.id).to eq(card_token)
+      expect(token.card.last4).to eq("2323")
+      expect(token.card.exp_month).to eq(33)
+      expect(token.card.exp_year).to eq(2222)
+    end
+  end
+
+  describe 'Stripe::Token' do
+
+    it "generates and reads a card token for create customer" do
+
+      card_token = Stripe::Token.create({
+        card: {
+          number: "4222222222222222",
+          exp_month: 9,
+          exp_year: 2017
+        }
+      })
+
+      cus = Stripe::Customer.create(source: card_token.id)
+      card = cus.sources.data.first
+      expect(card.last4).to eq("2222")
+      expect(card.exp_month).to eq(9)
+      expect(card.exp_year).to eq(2017)
+    end
+
+    it "generates and reads a card token for update customer" do
+      card_token = Stripe::Token.create({
+        card: {
+          number: "1111222233334444",
+          exp_month: 11,
+          exp_year: 2019
+        }
+      })
+
+      cus = Stripe::Customer.create
+      cus.source = card_token.id
+      cus.save
+
+      card = cus.sources.data.first
+      expect(card.last4).to eq("4444")
+      expect(card.exp_month).to eq(11)
+      expect(card.exp_year).to eq(2019)
+    end
+
+    it "generates a card token created from customer" do
+      card_token = Stripe::Token.create({
+        card: {
+          number: "1111222233334444",
+          exp_month: 11,
+          exp_year: 2019
+        }
+      })
+
+      cus = Stripe::Customer.create()
+      cus.source = card_token.id
+      cus.save
+
+      card_token = Stripe::Token.create({
+        customer: cus.id
+      })
+
+      expect(card_token.object).to eq("token")
+    end
+
+    it "generates a card token from another card" do
+      token = StripeMock.generate_card_token(last4: "2244", exp_month: 33, exp_year: 2255)
+
+      cus1 = Stripe::Customer.create()
+      cus1.source = token
+      cus1.save
+
+      card1 = cus1.sources.data.first
+      expect(card1.last4).to eq("2244")
+      expect(card1.exp_month).to eq(33)
+      expect(card1.exp_year).to eq(2255)
+
+      card_token = Stripe::Token.create({
+        customer: cus1.id,
+        card: card1.id
+      })
+
+      cus2 = Stripe::Customer.create()
+      cus2.source = card_token.id
+      cus2.save
+
+      card2 = cus2.sources.data.first
+      expect(card2.last4).to eq("2244")
+      expect(card2.exp_month).to eq(33)
+      expect(card2.exp_year).to eq(2255)
+    end
+
+    it 'generates a card token from another card', oauth: true do
+      token = Stripe::Token.create(
+          card: {
+              exp_month: 10,
+              exp_year: 2016,
+              number: '4242424242424242'
+          }
+      )
+
+      cus1 = Stripe::Customer.create(source: token.id)
+
+      card1 = cus1.sources.data.first
+      expect(card1.last4).to eq('4242')
+      expect(card1.exp_month).to eq(10)
+      expect(card1.exp_year).to eq(2016)
+
+      card_token = Stripe::Token.create(
+          {
+              customer: cus1.id,
+              card: card1.id
+          },
+          ENV['STRIPE_TEST_OAUTH_ACCESS_TOKEN'])
+
+      cus2 = Stripe::Customer.create({ source: card_token.id }, ENV['STRIPE_TEST_OAUTH_ACCESS_TOKEN'])
+
+      card2 = cus2.sources.data.first
+      expect(card2.last4).to eq('4242')
+      expect(card2.exp_month).to eq(10)
+      expect(card2.exp_year).to eq(2016)
+    end
+
+    it "throws an error if neither card nor customer are provided", :live => true do
+      expect { Stripe::Token.create }.to raise_error(
+        Stripe::InvalidRequestError, /must supply either a card, customer/
+      )
+    end
+  end
+
+end