stripe-ruby-mock 2.3.0 → 2.4.0

data/spec/shared_stripe_examples/refund_examples.rb

@@ -2,102 +2,465 @@ require 'spec_helper'
 
 shared_examples 'Refund API' do
 
-  it "refunds a stripe charge item" do
-    charge = Stripe::Charge.create(
-      amount: 999,
-      currency: 'USD',
-      card: 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
+  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'
+      )
 
-  it "creates a stripe refund with the charge ID", :live => true do
-    charge = Stripe::Charge.create(
-      amount: 999,
-      currency: 'USD',
-      card: 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
+      Stripe::Refund.create(
+        charge: charge.id
+      )
 
-  it "creates a stripe refund with a refund ID" do
-    charge = Stripe::Charge.create(
-      amount: 999,
-      currency: 'USD',
-      card: 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
+      charge = Stripe::Charge.retrieve(charge.id)
 
-  it "creates a stripe refund with a status" do
-    charge = Stripe::Charge.create(
-      amount: 999,
-      currency: 'USD',
-      card: 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',
-      card: 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
+      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)
 
-  it "creates a refund off a charge", :live => true do
-    original = Stripe::Charge.create(amount: 555, currency: 'USD', card: stripe_helper.generate_card_token)
+      refund.metadata[:order_id] = 6735
+      refund.save
 
-    charge = Stripe::Charge.retrieve(original.id)
+      updated = Stripe::Refund.retrieve(original.id)
 
-    refund = charge.refunds.create(amount: 555)
-    expect(refund.amount).to eq 555
-    expect(refund.charge).to eq charge.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([@refund.id, @refund2.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(:idempotent_refund_params) {{
+        charge: charge.id,
+        idempotency_key: 'onceisenough'
+      }}
+
+      it "returns the original refund if the same idempotency_key is passed in" do
+        refund1 = Stripe::Refund.create(idempotent_refund_params)
+        refund2 = Stripe::Refund.create(idempotent_refund_params)
+
+        expect(refund1).to eq(refund2)
+      end
+
+      it "returns different charges if different idempotency_keys are used for each charge" do
+        idempotent_refund_params2 = idempotent_refund_params.clone
+        idempotent_refund_params2[:idempotency_key] = 'thisoneisdifferent'
+
+        refund1 = Stripe::Refund.create(idempotent_refund_params)
+        refund2 = Stripe::Refund.create(idempotent_refund_params2)
+
+        expect(refund1).not_to eq(refund2)
+      end
+    end
   end
 
-  it "handles multiple refunds", :live => true do
-    original = Stripe::Charge.create(amount: 1100, currency: 'USD', card: stripe_helper.generate_card_token)
 
-    charge = Stripe::Charge.retrieve(original.id)
+  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_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
+      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
+      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
+      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

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -203,6 +203,7 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.id).to eq(sub.id)
       expect(customer.subscriptions.data.first.plan.to_hash).to eq(plan.to_hash)
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.charges.count).to eq(0)
     end
 
     it "subscribes a customer with no card to a free plan" do
@@ -288,6 +289,19 @@ shared_examples 'Customer Subscriptions' do
   end
 
   context "updating a subscription" do
+    it 'raises invalid request exception when subscription is cancelled' do
+      stripe_helper.create_plan(id: 'the truth')
+      customer = Stripe::Customer.create(source: gen_card_tk, plan: 'the truth')
+
+      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+      subscription.delete
+
+      expect { subscription.save }.to raise_error { |e|
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.http_status).to eq(404)
+        expect(e.message).to eq("No such subscription: #{subscription.id}")
+      }
+    end
 
     it "updates a stripe customer's existing subscription" do
       silver = stripe_helper.create_plan(id: 'silver')
@@ -347,6 +361,20 @@ shared_examples 'Customer Subscriptions' do
 
     end
 
+    it 'when coupon is removed' do
+      plan = stripe_helper.create_plan(id: 'plan_with_coupon3', name: 'One More Test Plan', amount: 777)
+      customer = Stripe::Customer.create(source: gen_card_tk, plan: plan.id)
+      coupon = stripe_helper.create_coupon
+      subscription = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+
+      subscription.coupon = coupon.id
+      subscription.save
+      subscription.coupon = nil
+      subscription.save
+
+      expect(subscription.discount).to be_nil
+    end
+
     it "throws an error when plan does not exist" do
       free = stripe_helper.create_plan(id: 'free', amount: 0)
       customer = Stripe::Customer.create(id: 'cardless', plan: 'free')

data/spec/support/stripe_examples.rb

@@ -25,6 +25,7 @@ def it_behaves_like_stripe(&block)
   it_behaves_like 'Stripe Error Mocking', &block
   it_behaves_like 'Customer Subscriptions', &block
   it_behaves_like 'Webhook Events API', &block
+  it_behaves_like 'Country Spec API', &block
 
   # Integration tests
   it_behaves_like 'Multiple Customer Cards'

data/stripe-ruby-mock.gemspec

@@ -17,11 +17,11 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']
 
-  gem.add_dependency 'stripe', ['>= 1.31.0', '<= 1.43']
-  gem.add_dependency 'multi_json', '>= 1.0.0'
+  gem.add_dependency 'stripe', '~> 1.31'
+  gem.add_dependency 'multi_json', '~> 1.0'
   gem.add_dependency 'dante', '>= 0.2.0'
 
   gem.add_development_dependency 'rspec', '~> 3.1.0'
   gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
-  gem.add_development_dependency 'thin'
+  gem.add_development_dependency 'thin', '~> 1.6.4'
 end