stripe-ruby-mock 2.5.6 → 3.1.0.rc2

data/spec/shared_stripe_examples/checkout_examples.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+shared_examples 'Checkout API' do
+
+  it "creates a stripe checkout session" do
+    session = Stripe::Checkout::Session.create({
+      payment_method_types: ['card'],
+      line_items: [{
+        name: 'T-shirt',
+        quantity: 1,
+        amount: 500,
+        currency: 'usd',
+      }],
+    })
+    expect(session.id).to match(/^test_cs/)
+    expect(session.line_items.count).to eq(1)
+  end
+
+  context 'retrieve a checkout session' do
+    let(:checkout_session1) { stripe_helper.create_checkout_session }
+
+    it 'ca be retrieved by id' do
+      checkout_session1
+
+      checkout_session = Stripe::Checkout::Session.retrieve(checkout_session1.id)
+
+      expect(checkout_session.id).to eq(checkout_session1.id)
+    end
+
+    it "cannot retrieve a checkout session that doesn't exist" do
+      expect { Stripe::Checkout::Session.retrieve('nope') }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.param).to eq('checkout_session')
+        expect(e.http_status).to eq(404)
+      }
+    end
+  end
+end

data/spec/shared_stripe_examples/coupon_examples.rb

@@ -53,7 +53,7 @@ shared_examples 'Coupon API' do
       coupon1
       coupon2
 
-      all = Stripe::Coupon.all
+      all = Stripe::Coupon.list
 
       expect(all.count).to eq(2)
       expect(all.map &:id).to include('10BUCKS', '11BUCKS')

data/spec/shared_stripe_examples/customer_examples.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 shared_examples 'Customer API' do
+  let(:product_params) { {id: "prod_CCC", name: "My Product", type: "service"} }
+  let(:product) { stripe_helper.create_product(product_params) }
 
   def gen_card_tk
     stripe_helper.generate_card_token
@@ -15,6 +17,7 @@ shared_examples 'Customer API' do
     expect(customer.id).to match(/^test_cus/)
     expect(customer.email).to eq('johnny@appleseed.com')
     expect(customer.description).to eq('a description')
+    expect(customer.preferred_locales).to eq([])
 
     expect(customer.sources.count).to eq(1)
     expect(customer.sources.data.length).to eq(1)
@@ -24,6 +27,17 @@ shared_examples 'Customer API' do
     expect { customer.source }.to raise_error
   end
 
+  it "creates a stripe customer with a default payment method" do
+    customer = Stripe::Customer.create({
+      email: 'johnny@appleseed.com',
+      invoice_settings: {
+        default_payment_method: "pm_1ExEuFL2DI6wht39WNJgbybl"
+      },
+      description: "a description"
+    })
+    expect(customer.invoice_settings.default_payment_method).to eq("pm_1ExEuFL2DI6wht39WNJgbybl")
+  end
+
   it "creates a stripe customer with multiple cards and updates the default card" do
     card_a   = gen_card_tk
     card_b   = gen_card_tk
@@ -78,8 +92,17 @@ shared_examples 'Customer API' do
     expect(customer.sources.data.first.exp_year).to eq 2024
   end
 
+  it 'creates a customer with name' do
+    customer = Stripe::Customer.create(
+      source: gen_card_tk,
+      name: 'John Appleseed'
+    )
+    expect(customer.id).to match(/^test_cus/)
+    expect(customer.name).to eq('John Appleseed')
+  end
+
   it 'creates a customer with a plan' do
-    plan = stripe_helper.create_plan(id: 'silver')
+    plan = stripe_helper.create_plan(id: 'silver', product: product.id)
     customer = Stripe::Customer.create(id: 'test_cus_plan', source: gen_card_tk, :plan => 'silver')
 
     customer = Stripe::Customer.retrieve('test_cus_plan')
@@ -91,24 +114,29 @@ shared_examples 'Customer API' do
     expect(customer.subscriptions.first.customer).to eq(customer.id)
   end
 
-  it "creates a customer with a plan (string/symbol agnostic)" do
-    plan = stripe_helper.create_plan(id: 'string_id')
-    customer = Stripe::Customer.create(id: 'test_cus_plan', source: gen_card_tk, :plan => :string_id)
-
-    customer = Stripe::Customer.retrieve('test_cus_plan')
-    expect(customer.subscriptions.first.plan.id).to eq('string_id')
+  it 'creates a customer with a plan (string/symbol agnostic)' do
+    stripe_helper.create_plan(id: 'silver', product: product.id)
 
-    plan = stripe_helper.create_plan(:id => :sym_id)
-    customer = Stripe::Customer.create(id: 'test_cus_plan', source: gen_card_tk, :plan => 'sym_id')
+    Stripe::Customer.create(id: 'cust_SLV1', source: gen_card_tk, :plan => 'silver')
+    customer = Stripe::Customer.retrieve('cust_SLV1')
+    expect(customer.subscriptions.count).to eq(1)
+    expect(customer.subscriptions.data.length).to eq(1)
+    expect(customer.subscriptions).to_not be_nil
+    expect(customer.subscriptions.first.plan.id).to eq('silver')
+    expect(customer.subscriptions.first.customer).to eq(customer.id)
 
-    customer = Stripe::Customer.retrieve('test_cus_plan')
-    expect(customer.subscriptions.first.plan.id).to eq('sym_id')
+    Stripe::Customer.create(id: 'cust_SLV2', source: gen_card_tk, :plan => :silver)
+    customer = Stripe::Customer.retrieve('cust_SLV2')
+    expect(customer.subscriptions.count).to eq(1)
+    expect(customer.subscriptions.data.length).to eq(1)
+    expect(customer.subscriptions).to_not be_nil
+    expect(customer.subscriptions.first.plan.id).to eq('silver')
+    expect(customer.subscriptions.first.customer).to eq(customer.id)
   end
 
   context "create customer" do
-
     it "with a trial when trial_end is set" do
-      plan = stripe_helper.create_plan(id: 'no_trial', amount: 999)
+      plan = stripe_helper.create_plan(id: 'no_trial', product: product.id, amount: 999)
       trial_end = Time.now.utc.to_i + 3600
       customer = Stripe::Customer.create(id: 'test_cus_trial_end', source: gen_card_tk, plan: 'no_trial', trial_end: trial_end)
 
@@ -124,7 +152,7 @@ shared_examples 'Customer API' do
     end
 
     it 'overrides trial period length when trial_end is set' do
-      plan = stripe_helper.create_plan(id: 'silver', amount: 999, trial_period_days: 14)
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id, amount: 999, trial_period_days: 14)
       trial_end = Time.now.utc.to_i + 3600
       customer = Stripe::Customer.create(id: 'test_cus_trial_end', source: gen_card_tk, plan: 'silver', trial_end: trial_end)
 
@@ -139,7 +167,7 @@ shared_examples 'Customer API' do
     end
 
     it 'creates a customer when trial_end is set and no source', live: true do
-      plan = stripe_helper.create_plan(id: 'silver', amount: 999)
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id, amount: 999)
       trial_end = Time.now.utc.to_i + 3600
       customer = Stripe::Customer.create(plan: 'silver', trial_end: trial_end)
       expect(customer.subscriptions.count).to eq(1)
@@ -152,7 +180,7 @@ shared_examples 'Customer API' do
     end
 
     it "returns no trial when trial_end is set to 'now'" do
-      plan = stripe_helper.create_plan(id: 'silver', amount: 999, trial_period_days: 14)
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id, amount: 999, trial_period_days: 14)
       customer = Stripe::Customer.create(id: 'test_cus_trial_end', source: gen_card_tk, plan: 'silver', trial_end: "now")
 
       customer = Stripe::Customer.retrieve('test_cus_trial_end')
@@ -166,8 +194,8 @@ shared_examples 'Customer API' do
       expect(customer.subscriptions.first.trial_end).to be_nil
     end
 
-    it "returns an error if trial_end is set to a past time" do
-      plan = stripe_helper.create_plan(id: 'silver', amount: 999)
+    it 'returns an error if trial_end is set to a past time' do
+      plan = stripe_helper.create_plan(id: 'silver', product: product.id, amount: 999)
       expect {
         Stripe::Customer.create(id: 'test_cus_trial_end', source: gen_card_tk, plan: 'silver', trial_end: Time.now.utc.to_i - 3600)
       }.to raise_error {|e|
@@ -176,7 +204,7 @@ shared_examples 'Customer API' do
       }
     end
 
-    it "returns an error if trial_end is set without a plan" do
+    it 'returns an error if trial_end is set without a plan' do
       expect {
         Stripe::Customer.create(id: 'test_cus_trial_end', source: gen_card_tk, trial_end: "now")
       }.to raise_error {|e|
@@ -189,7 +217,7 @@ shared_examples 'Customer API' do
 
   it 'cannot create a customer with a plan that does not exist' do
     expect {
-      customer = Stripe::Customer.create(id: 'test_cus_no_plan', source: gen_card_tk, :plan => 'non-existant')
+      Stripe::Customer.create(id: 'test_cus_no_plan', source: gen_card_tk, :plan => 'non-existant')
     }.to raise_error {|e|
       expect(e).to be_a(Stripe::InvalidRequestError)
       expect(e.message).to eq('No such plan: non-existant')
@@ -197,9 +225,9 @@ shared_examples 'Customer API' do
   end
 
   it 'cannot create a customer with an existing plan, but no card token' do
-    plan = stripe_helper.create_plan(id: 'p')
+    plan = stripe_helper.create_plan(id: 'p', product: product.id)
     expect {
-      customer = Stripe::Customer.create(id: 'test_cus_no_plan', :plan => 'p')
+      Stripe::Customer.create(id: 'test_cus_no_plan', :plan => 'p')
     }.to raise_error {|e|
       expect(e).to be_a(Stripe::InvalidRequestError)
       expect(e.message).to eq('You must supply a valid card')
@@ -207,10 +235,9 @@ shared_examples 'Customer API' do
   end
 
   it 'creates a customer with a coupon discount' do
-    coupon = Stripe::Coupon.create(id: "10PERCENT", duration: 'once')
+    coupon = Stripe::Coupon.create(id: '10PERCENT', duration: 'once')
 
-    customer =
-      Stripe::Customer.create(id: 'test_cus_coupon', coupon: '10PERCENT')
+    Stripe::Customer.create(id: 'test_cus_coupon', coupon: '10PERCENT')
 
     customer = Stripe::Customer.retrieve('test_cus_coupon')
     expect(customer.discount).to_not be_nil
@@ -222,40 +249,59 @@ shared_examples 'Customer API' do
   describe 'repeating coupon with duration limit', live: true do
     let!(:coupon) { stripe_helper.create_coupon(id: '10OFF', amount_off: 1000, currency: 'usd', duration: 'repeating', duration_in_months: 12) }
     let!(:customer) { Stripe::Customer.create(coupon: coupon.id) }
+
     it 'creates the discount with the end date', live: true do
       discount = Stripe::Customer.retrieve(customer.id).discount
       expect(discount).to_not be_nil
       expect(discount.coupon).to_not be_nil
-      expect(discount.end).to be_within(1).of (Time.now + 365 * 24 * 3600).to_i
+      expect(discount.end).to be_within(10).of (DateTime.now >> 12).to_time.to_i
     end
+
     after { Stripe::Coupon.retrieve(coupon.id).delete }
     after { Stripe::Customer.retrieve(customer.id).delete }
   end
 
   it 'cannot create a customer with a coupon that does not exist' do
     expect{
-      customer = Stripe::Customer.create(id: 'test_cus_no_coupon', coupon: '5OFF')
+      Stripe::Customer.create(id: 'test_cus_no_coupon', coupon: '5OFF')
     }.to raise_error {|e|
       expect(e).to be_a(Stripe::InvalidRequestError)
       expect(e.message).to eq('No such coupon: 5OFF')
     }
   end
 
+  context 'with coupon on customer' do
+    before do
+      Stripe::Coupon.create(id: '10PERCENT', duration: 'once')
+      Stripe::Customer.create(id: 'test_cus_coupon', coupon: '10PERCENT')
+    end
+
+    it 'remove the coupon from customer' do
+      customer = Stripe::Customer.retrieve('test_cus_coupon')
+      expect(customer.discount).to_not be_nil
+      expect(customer.discount.coupon).to_not be_nil
+      expect(customer.discount.customer).to eq customer.id
+      expect(customer.discount.start).to be_within(1).of Time.now.to_i
+
+      Stripe::Customer.update('test_cus_coupon', coupon: '')
+      customer = Stripe::Customer.retrieve('test_cus_coupon')
+      expect(customer.discount).to be_nil
+    end
+  end
+
   it "stores a created stripe customer in memory" do
-    customer = Stripe::Customer.create({
-      email: 'johnny@appleseed.com',
-      source: gen_card_tk
-    })
-    customer2 = Stripe::Customer.create({
-      email: 'bob@bobbers.com',
-      source: gen_card_tk
-    })
+    customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+    customer2 = Stripe::Customer.create(email: 'bob@bobbers.com')
     data = test_data_source(:customers)
-    expect(data[customer.id]).to_not be_nil
-    expect(data[customer.id][:email]).to eq('johnny@appleseed.com')
+    list = data[data.keys.first]
+
+    customer_hash = list[customer.id.to_sym] || list[customer.id]
+    expect(customer_hash).to_not be_nil
+    expect(customer_hash[:email]).to eq('johnny@appleseed.com')
 
-    expect(data[customer2.id]).to_not be_nil
-    expect(data[customer2.id][:email]).to eq('bob@bobbers.com')
+    customer2_hash = list[customer2.id.to_sym] || list[customer2.id]
+    expect(customer2_hash).to_not be_nil
+    expect(customer2_hash[:email]).to eq('bob@bobbers.com')
   end
 
   it "retrieves a stripe customer" do
@@ -267,6 +313,7 @@ shared_examples 'Customer API' do
 
     expect(customer.id).to eq(original.id)
     expect(customer.email).to eq(original.email)
+    expect(customer.name).to eq(nil)
     expect(customer.default_source).to eq(original.default_source)
     expect(customer.default_source).not_to be_a(Stripe::Card)
     expect(customer.subscriptions.count).to eq(0)
@@ -297,9 +344,9 @@ shared_examples 'Customer API' do
     Stripe::Customer.create({ email: 'one@one.com' })
     Stripe::Customer.create({ email: 'two@two.com' })
 
-    all = Stripe::Customer.all
+    all = Stripe::Customer.list
     expect(all.count).to eq(2)
-    expect(all.map &:email).to include('one@one.com', 'two@two.com')
+    expect(all.data.map &:email).to include('one@one.com', 'two@two.com')
   end
 
   it "updates a stripe customer" do
@@ -307,8 +354,9 @@ shared_examples 'Customer API' do
     email = original.email
 
     coupon = Stripe::Coupon.create(id: "10PERCENT", duration: 'once')
-    original.description = 'new desc'
-    original.coupon      = coupon.id
+    original.description       = 'new desc'
+    original.preferred_locales = %w(fr en)
+    original.coupon            = coupon.id
     original.save
 
     expect(original.email).to eq(email)
@@ -318,9 +366,19 @@ shared_examples 'Customer API' do
     customer = Stripe::Customer.retrieve("test_customer_update")
     expect(customer.email).to eq(original.email)
     expect(customer.description).to eq('new desc')
+    expect(customer.preferred_locales).to eq(%w(fr en))
     expect(customer.discount.coupon).to be_a Stripe::Coupon
   end
 
+  it "preserves stripe customer metadata" do
+    metadata = {user_id: "38"}
+    customer = Stripe::Customer.create(metadata: metadata)
+    expect(customer.metadata.to_h).to eq(metadata)
+
+    updated = Stripe::Customer.update(customer.id, metadata: {fruit: "apples"})
+    expect(updated.metadata.to_h).to eq(metadata.merge(fruit: "apples"))
+  end
+
   it "retrieves the customer's default source after it was updated" do
     customer = Stripe::Customer.create()
     customer.source = gen_card_tk
@@ -381,7 +439,7 @@ shared_examples 'Customer API' do
   end
 
   it "still has subscriptions after save when subscriptions unchanged" do
-    plan = stripe_helper.create_plan(id: 'silver')
+    plan = stripe_helper.create_plan(id: 'silver', product: product.id)
     original = Stripe::Customer.create(source: gen_card_tk, plan: 'silver')
     subscription = original.subscriptions.data.first
     subscription_id = subscription.id
@@ -394,7 +452,7 @@ shared_examples 'Customer API' do
   end
 
   it "should add a customer to a subscription" do
-    plan     = stripe_helper.create_plan(id: 'silver')
+    plan     = stripe_helper.create_plan(id: 'silver', product: product.id)
     customer = Stripe::Customer.create(source: gen_card_tk)
     customer.subscriptions.create(plan: plan.id)
 
@@ -407,14 +465,6 @@ shared_examples 'Customer API' do
     expect(customer.deleted).to eq(true)
   end
 
-  it 'works with the update_subscription method' do
-    stripe_helper.create_plan(id: 'silver')
-    cus   = Stripe::Customer.create(source: gen_card_tk)
-    expect {
-      cus.update_subscription(plan: 'silver')
-    }.not_to raise_error
-  end
-
   it "deletes a stripe customer discount" do
     original = Stripe::Customer.create(id: 'test_customer_update')
 

data/spec/shared_stripe_examples/dispute_examples.rb

@@ -71,14 +71,14 @@ shared_examples 'Dispute API' do
   describe "listing disputes" do
 
     it "retrieves all disputes" do
-      disputes = Stripe::Dispute.all
+      disputes = Stripe::Dispute.list
 
       expect(disputes.count).to eq(10)
       expect(disputes.map &:id).to include('dp_05RsQX2eZvKYlo2C0FRTGSSA','dp_15RsQX2eZvKYlo2C0ERTYUIA', 'dp_25RsQX2eZvKYlo2C0ZXCVBNM', 'dp_35RsQX2eZvKYlo2C0QAZXSWE', 'dp_45RsQX2eZvKYlo2C0EDCVFRT', 'dp_55RsQX2eZvKYlo2C0OIKLJUY', 'dp_65RsQX2eZvKYlo2C0ASDFGHJ', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ', 'dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_95RsQX2eZvKYlo2C0EDFRYUI')
     end
 
     it "retrieves disputes with a limit(3)" do
-      disputes = Stripe::Dispute.all(limit: 3)
+      disputes = Stripe::Dispute.list(limit: 3)
 
       expect(disputes.count).to eq(3)
       expected = ['dp_95RsQX2eZvKYlo2C0EDFRYUI','dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ']

data/spec/shared_stripe_examples/error_mock_examples.rb

@@ -6,13 +6,14 @@ def expect_card_error(code, param)
     expect(e.http_status).to eq(402)
     expect(e.code).to eq(code)
     expect(e.param).to eq(param)
+    expect(e.http_body).to eq(e.json_body.to_json)
   }
 end
 
 shared_examples 'Stripe Error Mocking' do
 
   it "mocks a manually given stripe card error" do
-    error = Stripe::CardError.new('Test Msg', 'param_name', 'bad_code', http_status: 444, http_body: 'body', json_body: 'json body')
+    error = Stripe::CardError.new('Test Msg', 'param_name', code: 'bad_code', http_status: 444, http_body: 'body', json_body: {})
     StripeMock.prepare_error(error)
 
     expect { Stripe::Customer.create() }.to raise_error {|e|
@@ -23,14 +24,14 @@ shared_examples 'Stripe Error Mocking' do
 
       expect(e.http_status).to eq(444)
       expect(e.http_body).to eq('body')
-      expect(e.json_body).to eq('json body')
+      expect(e.json_body).to eq({})
     }
   end
 
 
   it "mocks a manually gives stripe invalid request error" do
 
-    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', http_status: 987, http_body: 'ibody', json_body: 'json ibody')
+    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', http_status: 987, http_body: 'ibody', json_body: {})
     StripeMock.prepare_error(error)
 
     expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to raise_error {|e|
@@ -40,22 +41,22 @@ shared_examples 'Stripe Error Mocking' do
 
       expect(e.http_status).to eq(987)
       expect(e.http_body).to eq('ibody')
-      expect(e.json_body).to eq('json ibody')
+      expect(e.json_body).to eq({})
     }
   end
 
 
   it "mocks a manually gives stripe invalid auth error" do
-    error = Stripe::AuthenticationError.new('Bad Auth', http_status: 499, http_body: 'abody', json_body: 'json abody')
+    error = Stripe::AuthenticationError.new('Bad Auth', http_status: 499, http_body: 'abody', json_body: {})
     StripeMock.prepare_error(error)
 
-    expect { stripe_helper.create_plan() }.to raise_error {|e|
+    expect { stripe_helper.create_plan(id: "test_plan") }.to raise_error {|e|
       expect(e).to be_a(Stripe::AuthenticationError)
       expect(e.message).to eq('Bad Auth')
 
       expect(e.http_status).to eq(499)
       expect(e.http_body).to eq('abody')
-      expect(e.json_body).to eq('json abody')
+      expect(e.json_body).to eq({})
     }
   end