epopia-stripe-ruby-mock 2.5.8

data/spec/shared_stripe_examples/product_example.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+shared_examples 'Product API' do
+  it 'creates a product' do
+    product = Stripe::Product.create(
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    expect(product.name).to eq 'my awesome product'
+    expect(product.type).to eq 'service'
+  end
+
+  it 'retrieves a product' do
+    Stripe::Product.create(
+      id:   'test_prod_1',
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    product = Stripe::Product.retrieve('test_prod_1')
+
+    expect(product.name).to eq 'my awesome product'
+    expect(product.type).to eq 'service'
+  end
+
+  it 'updates a product' do
+    Stripe::Product.create(
+      id:   'test_prod_1',
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    Stripe::Product.update('test_prod_1', name: 'my lame product')
+
+    product = Stripe::Product.retrieve('test_prod_1')
+
+    expect(product.name).to eq 'my lame product'
+  end
+
+  it 'lists all products' do
+    2.times do |n|
+      Stripe::Product.create(
+        name: "product #{n}",
+        type: 'service'
+      )
+    end
+
+    products = Stripe::Product.list
+
+    expect(products.map(&:name)).to match_array ['product 0', 'product 1']
+  end
+
+  it 'destroys a product', live: true do
+    Stripe::Product.create(
+      id:   'test_prod_1',
+      name: 'my awesome product',
+      type: 'service'
+    )
+
+    Stripe::Product.delete('test_prod_1')
+
+    expect { Stripe::Product.retrieve('test_prod_1') }. to raise_error(Stripe::InvalidRequestError)
+  end
+end

data/spec/shared_stripe_examples/recipient_examples.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+shared_examples 'Recipient API' do
+
+  it "creates a stripe recipient with a default bank and card", skip: 'Stripe has deprecated Recipients' do
+    recipient = Stripe::Recipient.create({
+      type:  "corporation",
+      name: "MyCo",
+      email: "owner@myco.com",
+      bank_account: 'void_bank_token',
+      card: stripe_helper.generate_card_token
+    })
+    expect(recipient.id).to match /^test_rp/
+    expect(recipient.type).to eq('corporation')
+    expect(recipient.name).to eq('MyCo')
+    expect(recipient.email).to eq('owner@myco.com')
+    expect(recipient.default_card).to_not be_nil
+
+    expect(recipient.active_account).to_not be_nil
+    expect(recipient.active_account.bank_name).to_not be_nil
+    expect(recipient.active_account.last4).to_not be_nil
+
+    expect(recipient.cards.count).to eq(1)
+    expect(recipient.cards.data.length).to eq(1)
+    expect(recipient.default_card).to_not be_nil
+    expect(recipient.default_card).to eq recipient.cards.data.first.id
+
+    expect { recipient.card }.to raise_error
+  end
+
+  it "raises a error if params are invalid", skip: 'Stripe has deprecated Recipients' do
+    expect { Stripe::Recipient.create(name: "foo") }.to raise_error
+    expect { Stripe::Recipient.create(type: "individual") }.to raise_error
+    expect { Stripe::Recipient.create(name: "foo", type: "bar") }.to raise_error
+    expect { Stripe::Recipient.create(name: "foo", type: "individual") }.not_to raise_error
+  end
+
+  it "creates a stripe recipient without a card", skip: 'Stripe has deprecated Recipients' do
+    recipient = Stripe::Recipient.create({
+      type:  "corporation",
+      name: "MyCo",
+      email: "cardless@appleseed.com"
+    })
+    expect(recipient.id).to match(/^test_rp/)
+    expect(recipient.type).to eq('corporation')
+    expect(recipient.name).to eq('MyCo')
+    expect(recipient.email).to eq('cardless@appleseed.com')
+
+    expect(recipient.cards.count).to eq(0)
+    expect(recipient.cards.data.length).to eq(0)
+    expect(recipient.default_card).to be_nil
+  end
+
+  it "stores a created stripe recipient in memory", skip: 'Stripe has deprecated Recipients' do
+    recipient = Stripe::Recipient.create({
+      type:  "individual",
+      name: "Customer One",
+      bank_account: 'bank_account_token_1',
+      card: stripe_helper.generate_card_token
+    })
+    recipient2 = Stripe::Recipient.create({
+      type:  "individual",
+      name: "Customer Two",
+      bank_account: 'bank_account_token_1',
+      card: stripe_helper.generate_card_token
+    })
+    data = test_data_source(:recipients)
+    expect(data[recipient.id]).to_not be_nil
+    expect(data[recipient.id][:type]).to eq("individual")
+    expect(data[recipient.id][:name]).to eq("Customer One")
+    expect(data[recipient.id][:default_card]).to_not be_nil
+
+    expect(data[recipient2.id]).to_not be_nil
+    expect(data[recipient2.id][:type]).to eq("individual")
+    expect(data[recipient2.id][:name]).to eq("Customer Two")
+    expect(data[recipient2.id][:default_card]).to_not be_nil
+  end
+
+  it "retrieves a stripe recipient", skip: 'Stripe has deprecated Recipients' do
+    original = Stripe::Recipient.create({
+      type:  "individual",
+      name: "Bob",
+      email: "bob@example.com",
+      card: stripe_helper.generate_card_token
+    })
+    recipient = Stripe::Recipient.retrieve(original.id)
+
+    expect(recipient.id).to eq(original.id)
+    expect(recipient.type).to eq(original.type)
+    expect(recipient.name).to eq(original.name)
+    expect(recipient.email).to eq(original.email)
+    expect(recipient.default_card).to_not be_nil
+  end
+
+  it "cannot retrieve a recipient that doesn't exist", skip: 'Stripe has deprecated Recipients' do
+    expect { Stripe::Recipient.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('recipient')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  describe "Errors", :live => true, skip: 'Stripe has deprecated Recipients' do
+    it "throws an error when the customer does not have the retrieving card id" do
+      recipient = Stripe::Recipient.create(:name => "Bob Bobber", :type => "individual")
+      card_id = "card_123"
+      expect { recipient.cards.retrieve(card_id) }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.message).to include "Recipient", recipient.id, "does not have", card_id
+        expect(e.param).to eq 'card'
+        expect(e.http_status).to eq 404
+      }
+    end
+
+    it "throws an error when the name does not have both first and last"
+  end
+
+end

data/spec/shared_stripe_examples/refund_examples.rb

@@ -0,0 +1,472 @@
+require 'spec_helper'
+
+shared_examples 'Refund API' do
+
+  describe 'standard API' do
+    it "refunds a stripe charge item" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+
+      Stripe::Refund.create(
+        charge: charge.id
+      )
+
+      charge = Stripe::Charge.retrieve(charge.id)
+
+      expect(charge.refunded).to eq(true)
+      expect(charge.refunds.data.first.amount).to eq(999)
+      expect(charge.amount_refunded).to eq(999)
+    end
+
+    it "creates a stripe refund with a status" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+
+      Stripe::Refund.create(
+        charge: charge.id
+      )
+
+      charge = Stripe::Charge.retrieve(charge.id)
+
+      expect(charge.refunds.data.count).to eq 1
+      expect(charge.refunds.data.first.status).to eq("succeeded")
+    end
+
+    it "creates a stripe refund with a different balance transaction than the charge" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+
+      Stripe::Refund.create(
+        charge: charge.id
+      )
+
+      charge = Stripe::Charge.retrieve(charge.id)
+
+      expect(charge.balance_transaction).not_to eq(charge.refunds.data.first.balance_transaction)
+    end
+
+    it "creates a refund off a charge", :live => true do
+      original = Stripe::Charge.create(
+        amount: 555,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      )
+
+      charge = Stripe::Charge.retrieve(original.id)
+
+      refund = Stripe::Refund.create(
+        charge: charge.id,
+        amount: 555
+      )
+
+      expect(refund.amount).to eq 555
+      expect(refund.charge).to eq charge.id
+    end
+
+    it "handles multiple refunds", :live => true do
+      original = Stripe::Charge.create(
+        amount: 1100,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      )
+
+      charge = Stripe::Charge.retrieve(original.id)
+
+      refund_1 = Stripe::Refund.create(
+        charge: charge.id,
+        amount: 300
+      )
+      expect(refund_1.amount).to eq 300
+      expect(refund_1.charge).to eq charge.id
+
+      refund_2 = Stripe::Refund.create(
+        charge: charge.id,
+        amount: 400
+      )
+      expect(refund_2.amount).to eq 400
+      expect(refund_2.charge).to eq charge.id
+
+      expect(charge.refunds.count).to eq 0
+      expect(charge.refunds.total_count).to eq 0
+      expect(charge.amount_refunded).to eq 0
+
+      charge = Stripe::Charge.retrieve(original.id)
+      expect(charge.refunds.count).to eq 2
+      expect(charge.refunds.total_count).to eq 2
+      expect(charge.amount_refunded).to eq 700
+    end
+
+    it 'returns Stripe::Refund object', live: true do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+      refund = Stripe::Refund.create(
+        charge: charge.id,
+        amount: 500
+      )
+
+      expect(refund).to be_a(Stripe::Refund)
+      expect(refund.amount).to eq(500)
+    end
+
+    it 'refunds entire charge if amount is not set', live: true do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+      refund = Stripe::Refund.create(charge: charge.id)
+
+      expect(refund.amount).to eq(charge.amount)
+    end
+
+    it "stores a created stripe refund in memory" do
+      charge_1 = Stripe::Charge.create({
+        amount: 333,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      })
+      refund_1 = Stripe::Refund.create(
+        charge: charge_1.id,
+      )
+      charge_2 = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      })
+      refund_2 = Stripe::Refund.create(
+        charge: charge_2.id,
+      )
+
+      data = test_data_source(:refunds)
+      expect(data[refund_1.id]).to_not be_nil
+      expect(data[refund_1.id][:amount]).to eq(333)
+
+      expect(data[refund_2.id]).to_not be_nil
+      expect(data[refund_2.id][:amount]).to eq(777)
+    end
+
+    it "creates a balance transaction" do
+      charge = Stripe::Charge.create({
+        amount: 300,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      })
+      refund = Stripe::Refund.create(
+        charge: charge.id,
+      )
+      bal_trans = Stripe::BalanceTransaction.retrieve(refund.balance_transaction)
+      expect(bal_trans.amount).to eq(charge.amount * -1)
+      expect(bal_trans.fee).to eq(-39)
+      expect(bal_trans.source).to eq(refund.id)
+    end
+
+    it "can expand balance transaction" do
+      charge = Stripe::Charge.create({
+        amount: 300,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      })
+      refund = Stripe::Refund.create(
+        charge: charge.id,
+        expand: ['balance_transaction']
+      )
+      expect(refund.balance_transaction).to be_a(Stripe::BalanceTransaction)
+    end
+
+    it "retrieves a stripe refund" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token
+      })
+      original = Stripe::Refund.create(
+        charge: charge.id
+      )
+      refund = Stripe::Refund.retrieve(original.id)
+
+      expect(refund.id).to eq(original.id)
+      expect(refund.amount).to eq(original.amount)
+    end
+
+    it "cannot retrieve a refund that doesn't exist" do
+      expect { Stripe::Refund.retrieve('nope') }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.param).to eq('refund')
+        expect(e.http_status).to eq(404)
+      }
+    end
+
+    it "updates a stripe charge" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'Original description',
+      })
+      original = Stripe::Refund.create(charge: charge.id)
+      refund = Stripe::Refund.retrieve(original.id)
+
+      refund.metadata[:order_id] = 6735
+      refund.save
+
+      updated = Stripe::Refund.retrieve(original.id)
+
+      expect(updated.metadata.to_hash).to eq(refund.metadata.to_hash)
+    end
+
+    it "disallows most parameters on updating a stripe charge" do
+      charge = Stripe::Charge.create({
+        amount: 777,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'Original description',
+      })
+      original = Stripe::Refund.create(charge: charge.id)
+
+      refund = Stripe::Refund.retrieve(original.id)
+      refund.reason = "customer changed is mind"
+      refund.amount = 777
+
+      expect { refund.save }.to raise_error(Stripe::InvalidRequestError) do |error|
+        expect(error.message).to match(/Received unknown parameters/)
+        expect(error.message).to match(/reason/)
+        expect(error.message).to match(/amount/)
+      end
+    end
+
+    context "retrieving a list of charges" do
+      before do
+        customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+        customer2 = Stripe::Customer.create(email: 'johnny2@appleseed.com')
+        charge = Stripe::Charge.create(amount: 15, currency: 'usd', customer: customer.id)
+        @refund = Stripe::Refund.create(charge: charge.id)
+        charge2 = Stripe::Charge.create(amount: 27, currency: 'usd', customer: customer2.id)
+        @refund2 = Stripe::Refund.create(charge: charge2.id)
+      end
+
+      it "stores all charges in memory" do
+        expect(Stripe::Refund.all.data.map(&:id)).to eq([@refund2.id, @refund.id])
+      end
+
+      it "defaults count to 10 charges" do
+        11.times do
+          charge = Stripe::Charge.create(
+            amount: 1,
+            currency: 'usd',
+            source: stripe_helper.generate_card_token
+          )
+          Stripe::Refund.create(charge: charge.id)
+        end
+
+        expect(Stripe::Refund.all.data.count).to eq(10)
+      end
+
+      it "is marked as having more when more objects exist" do
+        11.times do
+          charge = Stripe::Charge.create(
+            amount: 1,
+            currency: 'usd',
+            source: stripe_helper.generate_card_token
+          )
+          Stripe::Refund.create(charge: charge.id)
+        end
+
+        expect(Stripe::Refund.all.has_more).to eq(true)
+      end
+
+      context "when passing limit" do
+        it "gets that many charges" do
+          expect(Stripe::Refund.all(limit: 1).count).to eq(1)
+        end
+      end
+    end
+
+    it 'when use starting_after param', live: true do
+      customer = Stripe::Customer.create(
+        description: 'Customer for test@example.com',
+        source: {
+          object: 'card',
+          number: '4242424242424242',
+          exp_month: 12,
+          exp_year: 2024,
+          cvc: 123
+        }
+      )
+      12.times do
+        charge = Stripe::Charge.create(
+          customer: customer.id,
+          amount: 100,
+          currency: 'usd'
+        )
+        Stripe::Refund.create(charge: charge.id)
+      end
+
+      all = Stripe::Refund.all
+      default_limit = 10
+      half = Stripe::Refund.all(starting_after: all.data.at(1).id)
+
+      expect(half).to be_a(Stripe::ListObject)
+      expect(half.data.count).to eq(default_limit)
+      expect(half.data.first.id).to eq(all.data.at(2).id)
+    end
+
+    describe "idempotency" do
+      let(:customer) { Stripe::Customer.create(email: 'johnny@appleseed.com') }
+      let(:charge) do
+        Stripe::Charge.create(
+          customer: customer.id,
+          amount: 777,
+          currency: 'USD',
+          capture: true
+        )
+      end
+      let(:refund_params) {{
+        charge: charge.id
+      }}
+
+      let(:refund_headers) {{
+        idempotency_key: 'onceisenough'
+      }}
+
+      it "returns the original refund if the same idempotency_key is passed in" do
+        refund1 = Stripe::Refund.create(refund_params, refund_headers)
+        refund2 = Stripe::Refund.create(refund_params, refund_headers)
+
+        expect(refund1).to eq(refund2)
+      end
+
+      context 'different key' do
+        let(:different_refund_headers) {{
+          idempotency_key: 'thisoneisdifferent'
+        }}
+
+        it "returns different charges if different idempotency_keys are used for each charge" do
+          refund1 = Stripe::Refund.create(refund_params, refund_headers)
+          refund2 = Stripe::Refund.create(refund_params, different_refund_headers)
+
+          expect(refund1).not_to eq(refund2)
+        end
+      end
+    end
+  end
+
+
+  describe 'charge refund API' do
+
+    it "refunds a stripe charge item" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+
+      charge = charge.refund(amount: 999)
+
+      expect(charge.refunded).to eq(true)
+      expect(charge.refunds.data.first.amount).to eq(999)
+      expect(charge.amount_refunded).to eq(999)
+    end
+
+    it "creates a stripe refund with the charge ID", :live => true do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+      refund = charge.refund
+
+      expect(charge.id).to match(/^(test_)?ch/)
+      expect(refund.id).to eq(charge.id)
+    end
+
+    it "creates a stripe refund with a refund ID" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+      refund = charge.refund
+
+      expect(refund.refunds.data.count).to eq 1
+      expect(refund.refunds.data.first.id).to match(/^test_re/)
+    end
+
+    it "creates a stripe refund with a status" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+      refund = charge.refund
+
+      expect(refund.refunds.data.count).to eq 1
+      expect(refund.refunds.data.first.status).to eq("succeeded")
+    end
+
+    it "creates a stripe refund with a different balance transaction than the charge" do
+      charge = Stripe::Charge.create(
+        amount: 999,
+        currency: 'USD',
+        source: stripe_helper.generate_card_token,
+        description: 'card charge'
+      )
+      refund = charge.refund
+
+      expect(charge.balance_transaction).not_to eq(refund.refunds.data.first.balance_transaction)
+    end
+
+    it "creates a refund off a charge", :live => true do
+      original = Stripe::Charge.create(amount: 555, currency: 'USD', source: stripe_helper.generate_card_token)
+
+      charge = Stripe::Charge.retrieve(original.id)
+
+      refund = charge.refunds.create(amount: 555)
+      expect(refund.amount).to eq 555
+      expect(refund.charge).to eq charge.id
+    end
+
+    it "handles multiple refunds", :live => true do
+      original = Stripe::Charge.create(amount: 1100, currency: 'USD', source: stripe_helper.generate_card_token)
+
+      charge = Stripe::Charge.retrieve(original.id)
+
+      refund_1 = charge.refunds.create(amount: 300)
+      expect(refund_1.amount).to eq 300
+      expect(refund_1.charge).to eq charge.id
+
+      refund_2 = charge.refunds.create(amount: 400)
+      expect(refund_2.amount).to eq 400
+      expect(refund_2.charge).to eq charge.id
+
+      expect(charge.refunds.count).to eq 0
+      expect(charge.refunds.total_count).to eq 0
+      expect(charge.amount_refunded).to eq 0
+
+      charge = Stripe::Charge.retrieve(original.id)
+      expect(charge.refunds.count).to eq 2
+      expect(charge.refunds.total_count).to eq 2
+      expect(charge.amount_refunded).to eq 700
+    end
+  end
+end