stripe-ruby-mock 1.10.1.7 → 2.0.0

data/spec/shared_stripe_examples/plan_examples.rb

@@ -47,9 +47,7 @@ shared_examples 'Plan API' do
 
 
   it "retrieves a stripe plan" do
-    original = Stripe::Plan.create({
-      amount: 1331
-    })
+    original = stripe_helper.create_plan(amount: 1331)
     plan = Stripe::Plan.retrieve(original.id)
 
     expect(plan.id).to eq(original.id)
@@ -58,7 +56,7 @@ shared_examples 'Plan API' do
 
 
   it "updates a stripe plan" do
-    Stripe::Plan.create(id: 'super_member', amount: 111)
+    stripe_helper.create_plan(id: 'super_member', amount: 111)
 
     plan = Stripe::Plan.retrieve('super_member')
     expect(plan.amount).to eq(111)
@@ -79,7 +77,7 @@ shared_examples 'Plan API' do
   end
 
   it "deletes a stripe plan" do
-    Stripe::Plan.create(id: 'super_member', amount: 111)
+    stripe_helper.create_plan(id: 'super_member', amount: 111)
 
     plan = Stripe::Plan.retrieve('super_member')
     expect(plan).to_not be_nil
@@ -94,29 +92,42 @@ shared_examples 'Plan API' do
   end
 
   it "retrieves all plans" do
-    Stripe::Plan.create({ id: 'Plan One', amount: 54321 })
-    Stripe::Plan.create({ id: 'Plan Two', amount: 98765 })
+    stripe_helper.create_plan(id: 'Plan One', amount: 54321)
+    stripe_helper.create_plan(id: 'Plan Two', amount: 98765)
 
     all = Stripe::Plan.all
     expect(all.length).to eq(2)
-    all.map(&:id).should include('Plan One', 'Plan Two')
-    all.map(&:amount).should include(54321, 98765)
+    expect(all.map &:id).to include('Plan One', 'Plan Two')
+    expect(all.map &:amount).to include(54321, 98765)
   end
 
 
-  context "With strict mode toggled off" do
+  describe "Validation", :live => true do
+    let(:params) { stripe_helper.create_plan_params }
+    let(:subject) { Stripe::Plan.create(params) }
 
-    before { StripeMock.toggle_strict(false) }
+    describe "Required Parameters" do
+      after do
+        params.delete(@name)
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, "Missing required param: #{@name}")
+      end
 
-    it "can retrieve a stripe plan with an id that doesn't exist" do
-      plan = Stripe::Plan.retrieve('test_charge_x')
+      it("requires a name") { @name = :name }
+      it("requires an amount") { @name = :amount }
+      it("requires a currency") { @name = :currency }
+      it("requires an interval") { @name = :interval }
+    end
+
+    describe "Uniqueness" do
 
-      expect(plan.id).to eq('test_charge_x')
-      expect(plan.amount).to_not be_nil
-      expect(plan.name).to_not be_nil
+      it "validates for uniqueness" do
+        stripe_helper.delete_plan(params[:id])
 
-      expect(plan.currency).to_not be_nil
-      expect(plan.interval).to_not be_nil
+        Stripe::Plan.create(params)
+        expect {
+          Stripe::Plan.create(params)
+        }.to raise_error(Stripe::InvalidRequestError, "Plan already exists.")
+      end
     end
   end
 

data/spec/shared_stripe_examples/recipient_examples.rb

@@ -2,52 +2,87 @@ require 'spec_helper'
 
 shared_examples 'Recipient API' do
 
-  it "creates a stripe recipient with a default card" do
+  it "creates a stripe recipient with a default bank and card" do
     recipient = Stripe::Recipient.create({
       type:  "corporation",
       name: "MyCo",
       email: "owner@myco.com",
-      bank_account: 'void_bank_token'
+      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 "creates a stripe recipient without a card" 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" do
     recipient = Stripe::Recipient.create({
       type:  "individual",
       name: "Customer One",
-      bank_account: 'bank_account_token_1'
+      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'
+      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" do
     original = Stripe::Recipient.create({
       type:  "individual",
       name: "Bob",
-      email: "bob@example.com"
+      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" do
@@ -58,5 +93,20 @@ shared_examples 'Recipient API' do
     }
   end
 
+  describe "Errors", :live => true 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,90 @@
+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
+
+  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
+
+  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
+
+  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
+
+  it "creates a refund off a charge", :live => true do
+    original = Stripe::Charge.create(amount: 555, currency: 'USD', card: 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', card: 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