stripe-ruby-mock 2.5.8 → 4.0.0

data/spec/shared_stripe_examples/charge_examples.rb

@@ -278,20 +278,6 @@ shared_examples 'Charge API' do
     }.not_to raise_error
   end
 
-  it "marks a charge as safe" do
-    original = Stripe::Charge.create({
-      amount: 777,
-      currency: 'USD',
-      source: stripe_helper.generate_card_token
-    })
-    charge = Stripe::Charge.retrieve(original.id)
-
-    charge.mark_as_safe
-
-    updated = Stripe::Charge.retrieve(original.id)
-    expect(updated.fraud_details[:user_report]).to eq "safe"
-  end
-
   it "does not lose data when updating a charge" do
     original = Stripe::Charge.create({
       amount: 777,
@@ -357,28 +343,29 @@ shared_examples 'Charge API' do
     end
 
     it "stores charges for a customer in memory" do
-      expect(@customer.charges.data.map(&:id)).to eq([@charge.id])
+      charges = Stripe::Charge.list(customer: @customer.id)
+      expect(charges.map(&:id)).to eq([@charge.id])
     end
 
     it "stores all charges in memory" do
-      expect(Stripe::Charge.all.data.map(&:id).reverse).to eq([@charge.id, @charge2.id])
+      expect(Stripe::Charge.list.data.map(&:id).reverse).to eq([@charge.id, @charge2.id])
     end
 
     it "defaults count to 10 charges" do
       11.times { Stripe::Charge.create(amount: 1, currency: 'usd', source: stripe_helper.generate_card_token) }
 
-      expect(Stripe::Charge.all.data.count).to eq(10)
+      expect(Stripe::Charge.list.data.count).to eq(10)
     end
 
     it "is marked as having more when more objects exist" do
       11.times { Stripe::Charge.create(amount: 1, currency: 'usd', source: stripe_helper.generate_card_token) }
 
-      expect(Stripe::Charge.all.has_more).to eq(true)
+      expect(Stripe::Charge.list.has_more).to eq(true)
     end
 
     context "when passing limit" do
       it "gets that many charges" do
-        expect(Stripe::Charge.all(limit: 1).count).to eq(1)
+        expect(Stripe::Charge.list(limit: 1).count).to eq(1)
       end
     end
   end
@@ -398,13 +385,13 @@ shared_examples 'Charge API' do
       Stripe::Charge.create(customer: cus.id, amount: 100, currency: "usd")
     end
 
-    all = Stripe::Charge.all
+    all_charges = Stripe::Charge.list
     default_limit = 10
-    half = Stripe::Charge.all(starting_after: all.data.at(1).id)
+    half = Stripe::Charge.list(starting_after: all_charges.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)
+    expect(half.data.first.id).to eq(all_charges.data.at(2).id)
   end
 
 
@@ -507,4 +494,101 @@ shared_examples 'Charge API' do
     end
   end
 
+  context "search" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches charges for exact matches", :aggregate_failures do
+      response = Stripe::Charge.search({query: 'amount:100'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+      one = Stripe::Charge.create(
+        customer: customer.id,
+        amount: 100,
+        currency: "usd",
+        payment_method_details: {
+          card: StripeMock::Data.mock_charge[:payment_method_details][:card].merge(
+            brand: "mastercard",
+            exp_month: 1,
+            exp_year: 2111,
+            fingerprint: "un",
+            last4: "1111",
+          ),
+        },
+        status: "succeeded",
+        metadata: {key: 'uno'},
+      )
+      two = Stripe::Charge.create(
+        customer: customer.id,
+        amount: 200,
+        currency: "gbp",
+        payment_method_details: {
+          card: StripeMock::Data.mock_charge[:payment_method_details][:card].merge(
+            brand: "visa",
+            exp_month: 2,
+            exp_year: 2222,
+            fingerprint: "deux",
+            last4: "2222",
+          ),
+        },
+        status: "pending",
+        metadata: {key: 'dos'},
+      )
+
+      response = Stripe::Charge.search({query: 'amount:100'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'currency:"gbp"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Charge.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.brand:mastercard'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.exp_month:2'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.exp_year:2111'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.fingerprint:un'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'payment_method_details.card.last4:2222'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Charge.search({query: 'status:"succeeded"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Charge.search({query: 'metadata["key"]:"uno"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+    end
+
+    it "respects limit", :aggregate_failures do
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com')
+      11.times do
+        Stripe::Charge.create(customer: customer.id, amount: 100, currency: "usd")
+      end
+
+      response = Stripe::Charge.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Charge.search({query: %(customer:"#{customer.id}"), limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Charge.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Charge.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Charge.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `charges`./)
+    end
+  end
 end

data/spec/shared_stripe_examples/checkout_session_examples.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+shared_examples "Checkout Session API" do
+  it "creates PaymentIntent with payment mode" do
+    line_items = [{
+      name: "T-shirt",
+      quantity: 2,
+      amount: 500,
+      currency: "usd",
+    }]
+    session = Stripe::Checkout::Session.create(
+      payment_method_types: ["card"],
+      line_items: line_items,
+      cancel_url: "https://example.com/cancel",
+      success_url: "https://example.com/success"
+    )
+
+    expect(session.payment_intent).to_not be_empty
+    payment_intent = Stripe::PaymentIntent.retrieve(session.payment_intent)
+    expect(payment_intent.amount).to eq(1000)
+    expect(payment_intent.currency).to eq("usd")
+    expect(payment_intent.customer).to eq(session.customer)
+  end
+
+  context "when creating a payment" do
+    it "requires line_items" do
+      expect do
+        session = Stripe::Checkout::Session.create(
+          customer: "customer_id",
+          success_url: "localhost/nada",
+          cancel_url: "localhost/nada",
+          payment_method_types: ["card"],
+        )
+      end.to raise_error(Stripe::InvalidRequestError, /line_items/i)
+
+    end
+  end
+
+  it "creates SetupIntent with setup mode" do
+    session = Stripe::Checkout::Session.create(
+      mode: "setup",
+      payment_method_types: ["card"],
+      cancel_url: "https://example.com/cancel",
+      success_url: "https://example.com/success"
+    )
+
+    expect(session.setup_intent).to_not be_empty
+    setup_intent = Stripe::SetupIntent.retrieve(session.setup_intent)
+    expect(setup_intent.payment_method_types).to eq(["card"])
+  end
+
+  context "when creating a subscription" do
+    it "requires line_items" do
+      expect do
+        session = Stripe::Checkout::Session.create(
+          customer: "customer_id",
+          success_url: "localhost/nada",
+          cancel_url: "localhost/nada",
+          payment_method_types: ["card"],
+          mode: "subscription",
+        )
+      end.to raise_error(Stripe::InvalidRequestError, /line_items/i)
+
+    end
+  end
+
+  context "retrieve a checkout session" do
+    let(:checkout_session1) { stripe_helper.create_checkout_session }
+
+    it "can 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
+
+    it "can expand setup_intent" do
+      initial_session = Stripe::Checkout::Session.create(
+        mode: "setup",
+        cancel_url: "https://example.com",
+        success_url: "https://example.com",
+        payment_method_types: ["card"]
+      )
+
+      checkout_session = Stripe::Checkout::Session.retrieve(id: initial_session.id, expand: ["setup_intent"])
+
+      expect(checkout_session.setup_intent).to be_a_kind_of(Stripe::SetupIntent)
+    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
@@ -88,7 +102,7 @@ shared_examples 'Customer API' do
   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')
@@ -100,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)
 
@@ -133,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)
 
@@ -148,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)
@@ -161,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')
@@ -175,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|
@@ -185,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|
@@ -198,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')
@@ -206,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')
@@ -216,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
@@ -231,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.to_datetime >> 12).to_time.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]
 
-    expect(data[customer2.id]).to_not be_nil
-    expect(data[customer2.id][:email]).to eq('bob@bobbers.com')
+    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')
+
+    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
@@ -307,9 +344,65 @@ 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
+
+  context "search" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches customers for exact matches", :aggregate_failures do
+      response = Stripe::Customer.search({query: 'email:"one@one.com"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      one = Stripe::Customer.create(email: 'one@one.com', name: 'one', phone: '1111111111', metadata: {key: 'uno'})
+      two = Stripe::Customer.create(email: 'two@two.com', name: 'two', phone: '2222222222', metadata: {key: 'dos'})
+
+      response = Stripe::Customer.search({query: 'email:"one@one.com"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Customer.search({query: 'name:"two"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Customer.search({query: 'phone:"2222222222"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Customer.search({query: 'metadata["key"]:"uno"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+    end
+
+    it "respects limit", :aggregate_failures do
+      one = Stripe::Customer.create(email: 'one@one.com', name: 'one')
+      two = Stripe::Customer.create(email: 'two@two.com', name: 'one')
+      three = Stripe::Customer.create(email: 'three@three.com', name: 'one')
+      four = Stripe::Customer.create(email: 'four@four.com', name: 'one')
+      five = Stripe::Customer.create(email: 'five@five.com', name: 'one')
+      six = Stripe::Customer.create(email: 'six@six.com', name: 'one')
+      seven = Stripe::Customer.create(email: 'seven@seven.com', name: 'one')
+      eight = Stripe::Customer.create(email: 'eight@eight.com', name: 'one')
+      nine = Stripe::Customer.create(email: 'nine@nine.com', name: 'one')
+      ten = Stripe::Customer.create(email: 'ten@ten.com', name: 'one')
+      eleven = Stripe::Customer.create(email: 'eleven@eleven.com', name: 'one')
+
+      response = Stripe::Customer.search({query: 'name:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Customer.search({query: 'name:"one"', limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Customer.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Customer.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Customer.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `customers`./)
+    end
   end
 
   it "updates a stripe customer" do
@@ -317,8 +410,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)
@@ -328,9 +422,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
@@ -391,7 +495,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
@@ -404,7 +508,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)
 
@@ -417,14 +521,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']