stripe-ruby-mock 3.1.0.rc3 → 4.0.0

data/spec/shared_stripe_examples/customer_examples.rb

@@ -349,6 +349,62 @@ shared_examples 'Customer API' do
     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
     original = Stripe::Customer.create(id: 'test_customer_update')
     email = original.email

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -14,6 +14,11 @@ shared_examples 'Invoice API' do
       expect(data[invoice.id]).to_not be_nil
       expect(data[invoice.id][:id]).to eq(invoice.id)
     end
+
+    it "supports invoice number" do
+      original = Stripe::Invoice.create
+      expect(original.number).to be
+    end
   end
 
   context "retrieving an invoice" do
@@ -74,6 +79,88 @@ shared_examples 'Invoice API' do
     end
   end
 
+  context "searching invoices" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches invoices for exact matches", :aggregate_failures do
+      response = Stripe::Invoice.search({query: 'currency:"usd"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      product = stripe_helper.create_product
+      stripe_helper.create_plan(
+        amount: 500,
+        interval: 'month',
+        product: product.id,
+        currency: 'usd',
+        id: 'Sample5',
+      )
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com', source: stripe_helper.generate_card_token)
+      subscription = Stripe::Subscription.create(customer: customer.id, items: [{plan: 'Sample5'}])
+      one = Stripe::Invoice.create(
+        customer: customer.id,
+        currency: 'usd',
+        subscription: subscription.id,
+        metadata: {key: 'uno'},
+        number: 'one-1',
+        receipt_number: '111',
+      )
+      two = Stripe::Invoice.create(
+        customer: customer.id,
+        currency: 'gbp',
+        subscription: subscription.id,
+        metadata: {key: 'dos'},
+        number: 'two-2',
+        receipt_number: '222',
+      )
+
+      response = Stripe::Invoice.search({query: 'currency:"gbp"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Invoice.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Invoice.search({query: 'number:"one-1"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Invoice.search({query: 'receipt_number:"222"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Invoice.search({query: %(subscription:"#{subscription.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Invoice.search({query: 'total:1000'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Invoice.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: 'one@one.com', name: 'one', phone: '1111111111', metadata: {key: 'uno'})
+      11.times do
+        Stripe::Invoice.create(customer: customer.id, currency: 'usd')
+      end
+
+      response = Stripe::Invoice.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Invoice.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::Invoice.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Invoice.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Invoice.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `invoices`./)
+    end
+  end
+
   context "paying an invoice" do
     before do
       @invoice = Stripe::Invoice.create
@@ -83,12 +170,28 @@ shared_examples 'Invoice API' do
       @invoice = @invoice.pay
       expect(@invoice.attempted).to eq(true)
       expect(@invoice.paid).to eq(true)
+      expect(@invoice.status).to eq("paid")
     end
 
     it 'creates a new charge object' do
       expect{ @invoice.pay }.to change { Stripe::Charge.list.data.count }.by 1
     end
 
+    it 'should work with Stripe::Invoice.pay(invoice_id)' do
+      expect(@invoice.paid).to_not eq(true)
+
+      expect {
+        Stripe::Invoice.pay(@invoice.id)
+      }.to change { Stripe::Charge.list.data.count }.by 1
+
+      @invoice = Stripe::Invoice.retrieve(id: @invoice.id)
+      expect(@invoice).to_not be_nil
+
+      expect(@invoice.attempted).to eq(true)
+      expect(@invoice.paid).to eq(true)
+      expect(@invoice.status).to eq("paid")
+    end
+
     it 'sets the charge attribute' do
       @invoice = @invoice.pay
       expect(@invoice.charge).to be_a String
@@ -133,7 +236,10 @@ shared_examples 'Invoice API' do
     describe 'parameter validation' do
       it 'fails without parameters' do
         expect { Stripe::Invoice.upcoming() }.to raise_error {|e|
-          expect(e).to be_a(ArgumentError) }
+        expect(e).to be_a(Stripe::InvalidRequestError)
+        expect(e.http_status).to eq(400)
+        expect(e.message).to eq('Missing required param: customer if subscription is not provided') 
+      }
       end
 
       it 'fails without a valid customer' do

data/spec/shared_stripe_examples/payment_intent_examples.rb

@@ -2,6 +2,11 @@ require 'spec_helper'
 
 shared_examples 'PaymentIntent API' do
 
+  let(:customer) do
+    token = Stripe::Token.retrieve(stripe_helper.generate_card_token(number: '4242424242424242'))
+    Stripe::Customer.create(email: 'alice@bob.com', source: token.id)
+  end
+
   it "creates a succeeded stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount:  100, currency: "usd")
 
@@ -92,6 +97,35 @@ shared_examples 'PaymentIntent API' do
     expect(Stripe::BalanceTransaction.retrieve(balance_txn).id).to eq(balance_txn)
   end
 
+  it 'creates a charge for a stripe payment_intent with confirm flag to true' do
+    payment_intent = Stripe::PaymentIntent.create amount: 100,
+                                                  currency: 'usd',
+                                                  confirm: true,
+                                                  customer: customer,
+                                                  payment_method: customer.sources.first
+
+    charge = payment_intent.charges.data.first
+    expect(charge.amount).to eq(payment_intent.amount)
+    expect(charge.payment_intent).to eq(payment_intent.id)
+    expect(charge.description).to be_nil
+
+    charge.description = 'Updated description'
+    charge.save
+
+    updated = Stripe::Charge.retrieve(charge.id)
+    expect(updated.description).to eq('Updated description')
+  end
+
+  it "includes the payment_method on charges" do
+    payment_intent = Stripe::PaymentIntent.create(
+      amount: 100, currency: "usd", confirm: true, payment_method: "test_pm_1"
+    )
+    expect(payment_intent.status).to eq("succeeded")
+    expect(payment_intent.charges.data.size).to eq(1)
+    expect(payment_intent.charges.data.first.object).to eq("charge")
+    expect(payment_intent.charges.data.first.payment_method).to eq("test_pm_1")
+  end
+
   it "confirms a stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
     confirmed_payment_intent = payment_intent.confirm()
@@ -100,6 +134,25 @@ shared_examples 'PaymentIntent API' do
     expect(confirmed_payment_intent.charges.data.first.object).to eq('charge')
   end
 
+  it 'creates a charge for a confirmed stripe payment_intent' do
+    payment_intent = Stripe::PaymentIntent.create amount: 100,
+                                                  currency: 'usd',
+                                                  customer: customer,
+                                                  payment_method: customer.sources.first
+
+    confirmed_payment_intent = payment_intent.confirm
+    charge = confirmed_payment_intent.charges.data.first
+    expect(charge.amount).to eq(confirmed_payment_intent.amount)
+    expect(charge.payment_intent).to eq(confirmed_payment_intent.id)
+    expect(charge.description).to be_nil
+
+    charge.description = 'Updated description'
+    charge.save
+
+    updated = Stripe::Charge.retrieve(charge.id)
+    expect(updated.description).to eq('Updated description')
+  end
+
   it "captures a stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
     confirmed_payment_intent = payment_intent.capture()
@@ -108,6 +161,27 @@ shared_examples 'PaymentIntent API' do
     expect(confirmed_payment_intent.charges.data.first.object).to eq('charge')
   end
 
+  it 'creates a charge for a captured stripe payment_intent' do
+    payment_intent = Stripe::PaymentIntent.create amount: 3055,
+                                                  currency: 'usd',
+                                                  customer: customer,
+                                                  payment_method: customer.sources.first,
+                                                  confirm: true,
+                                                  capture_method: 'manual'
+
+    captured_payment_intent = payment_intent.capture
+    charge = captured_payment_intent.charges.data.first
+    expect(charge.amount).to eq(captured_payment_intent.amount)
+    expect(charge.payment_intent).to eq(captured_payment_intent.id)
+    expect(charge.description).to be_nil
+
+    charge.description = 'Updated description'
+    charge.save
+
+    updated = Stripe::Charge.retrieve(charge.id)
+    expect(updated.description).to eq('Updated description')
+  end
+
   it "cancels a stripe payment_intent" do
     payment_intent = Stripe::PaymentIntent.create(amount: 100, currency: "usd")
     confirmed_payment_intent = payment_intent.cancel()
@@ -144,4 +218,66 @@ shared_examples 'PaymentIntent API' do
       expect(e.http_status).to eq(400)
     }
   end
+
+  context "search" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches payment intents for exact matches", :aggregate_failures do
+      response = Stripe::PaymentIntent.search({query: 'currency:"usd"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      customer = Stripe::Customer.create(email: 'johnny@appleseed.com', source: stripe_helper.generate_card_token)
+      one = Stripe::PaymentIntent.create(
+        amount: 100,
+        customer: customer.id,
+        currency: 'usd',
+        metadata: {key: 'uno'},
+      )
+      two = Stripe::PaymentIntent.create(
+        amount: 3184, # status: requires_action
+        customer: customer.id,
+        currency: 'gbp',
+        metadata: {key: 'dos'},
+      )
+
+      response = Stripe::PaymentIntent.search({query: 'amount:100'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::PaymentIntent.search({query: 'currency:"gbp"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::PaymentIntent.search({query: %(customer:"#{customer.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::PaymentIntent.search({query: 'status:"requires_action"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::PaymentIntent.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
+      11.times do
+        Stripe::PaymentIntent.create(amount: 100, currency: 'usd')
+      end
+
+      response = Stripe::PaymentIntent.search({query: 'amount:100'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::PaymentIntent.search({query: 'amount:100', limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::PaymentIntent.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::PaymentIntent.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::PaymentIntent.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `payment_intents`./)
+    end
+  end
 end

data/spec/shared_stripe_examples/payment_method_examples.rb

@@ -25,6 +25,12 @@ shared_examples 'PaymentMethod API' do
       cvc: 999
     }
   end
+  let(:visa_card_details) do
+    card_details
+  end
+  let(:mastercard_card_details) do
+    card_details.merge(:number => 5555_5555_5555_4444)
+  end
   let(:sepa_debit_details) do
     {
       iban: 'DE89370400440532013000'
@@ -385,6 +391,7 @@ shared_examples 'PaymentMethod API' do
           .from(original_card_exp_month).to(new_card_exp_month)
       end
 
+
       context 'without a customer' do
         it 'raises invalid requestion exception' do
           expect do
@@ -394,29 +401,39 @@ shared_examples 'PaymentMethod API' do
       end
     end
 
+    context 'with visa card' do
+      let(:payment_method) do
+        Stripe::PaymentMethod.create(type: 'card', card: visa_card_details)
+      end
+
+      it 'uses correct brand' do
+        expect(payment_method.card.brand).to eq('visa')
+      end
+    end
+
+    context 'with mastercard card' do
+      let(:payment_method) do
+        Stripe::PaymentMethod.create(type: 'card', card: mastercard_card_details)
+      end
+
+      it 'uses correct brand' do
+        expect(payment_method.card.brand).to eq('mastercard')
+      end
+    end
+
     context 'with ideal' do
       let(:payment_method) do
         Stripe::PaymentMethod.create(type: 'ideal', ideal: ideal_details)
       end
 
-      it 'updates the ideal for the payment method' do
+      it 'cannot update' do
         Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
 
-        original_ideal_bank = payment_method.ideal.bank
         new_ideal_bank = 12
 
         expect do
           Stripe::PaymentMethod.update(payment_method.id, ideal: { bank: new_ideal_bank })
-        end.to change { Stripe::PaymentMethod.retrieve(payment_method.id).ideal.bank }
-          .from(original_ideal_bank).to(new_ideal_bank)
-      end
-
-      context 'without a customer' do
-        it 'raises invalid requestion exception' do
-          expect do
-            Stripe::PaymentMethod.update(payment_method.id, ideal: { bank: 12 })
-          end.to raise_error(Stripe::InvalidRequestError)
-        end
+        end.to raise_error(Stripe::InvalidRequestError)
       end
     end
 
@@ -425,24 +442,12 @@ shared_examples 'PaymentMethod API' do
         Stripe::PaymentMethod.create(type: 'sepa_debit', sepa_debit: sepa_debit_details)
       end
 
-      it 'updates the sepa_debit for the payment method' do
+      it 'cannot update' do
         Stripe::PaymentMethod.attach(payment_method.id, customer: customer.id)
 
-        original_iban = payment_method.sepa_debit.iban
-        new_iban = 'DE62370400440532013001'
-
         expect do
-          Stripe::PaymentMethod.update(payment_method.id, sepa_debit: { iban: new_iban })
-        end.to change { Stripe::PaymentMethod.retrieve(payment_method.id).sepa_debit.iban }
-          .from(original_iban).to(new_iban)
-      end
-
-      context 'without a customer' do
-        it 'raises invalid requestion exception' do
-          expect do
-            Stripe::PaymentMethod.update(payment_method.id, sepa_debit: { iban: 'DE62370400440532013001' })
-          end.to raise_error(Stripe::InvalidRequestError)
-        end
+          Stripe::PaymentMethod.update(payment_method.id, sepa_debit: { iban: 'DE62370400440532013001'})
+        end.to raise_error(Stripe::InvalidRequestError)
       end
     end
   end

data/spec/shared_stripe_examples/price_examples.rb

@@ -1,8 +1,11 @@
 require 'spec_helper'
 
 shared_examples 'Price API' do
-  let(:product) { stripe_helper.create_product }
-  let(:product_id) { product.id }
+  let(:product_id) { "product_id_1" }
+  let(:product) { stripe_helper.create_product(id: product_id) }
+
+  let(:other_product_id) { "product_id_2" }
+  let(:other_product) { stripe_helper.create_product(id: other_product_id) }
 
   let(:price_attributes) { {
     :id => "price_abc123",
@@ -26,6 +29,7 @@ shared_examples 'Price API' do
 
   before(:each) do
     product
+    other_product
   end
 
   it "creates a stripe price" do
@@ -124,6 +128,111 @@ shared_examples 'Price API' do
     expect(two.map &:id).to include('price Two')
     expect(two.map &:amount).to include(98765)
   end
+  
+  it "retrieves prices filtering by currency" do
+    5.times do | i|
+      stripe_helper.create_price(id: "usd price #{i}", product: product_id, amount: 11, currency: 'usd')
+      stripe_helper.create_price(id: "brl price #{i}", product: product_id, amount: 11, currency: 'brl')
+    end
+
+    all = Stripe::Price.list()
+    expect(all.count).to eq(10)
+
+    usd = Stripe::Price.list({currency: 'usd'})
+    expect(usd.count).to eq(5)
+    expect(usd.all? {|p| p.currency == 'usd' }).to be_truthy
+
+    brl = Stripe::Price.list({currency: 'brl'})
+    expect(brl.count).to eq(5)
+    expect(brl.all? {|p| p.currency == 'brl' }).to be_truthy
+  end
+
+  it "retrieves prices filtering by product" do
+    5.times do | i|
+      stripe_helper.create_price(id: "product 1 price #{i}", product: product_id)
+      stripe_helper.create_price(id: "product 2 price #{i}", product: other_product_id)
+    end
+
+    all = Stripe::Price.list()
+    expect(all.count).to eq(10)
+
+    product_prices = Stripe::Price.list({product: product.id})
+    expect(product_prices.count).to eq(5)
+    expect(product_prices.all? {|p| p.product == product.id }).to be_truthy
+
+    other_product_prices = Stripe::Price.list({product: other_product.id})
+    expect(other_product_prices.count).to eq(5)
+    expect(other_product_prices.all? {|p| p.product == other_product.id }).to be_truthy
+  end
+
+  context "searching prices" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches prices for exact matches", :aggregate_failures do
+      response = Stripe::Price.search({query: 'currency:"usd"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      one = stripe_helper.create_price(
+        amount: 100,
+        currency: 'usd',
+        lookup_key: 'one',
+        product: product_id,
+        metadata: {key: 'uno'},
+        type: "one_time",
+      )
+      two = stripe_helper.create_price(
+        active: false,
+        amount: 200,
+        currency: 'gbp',
+        lookup_key: 'two',
+        product: product_id,
+        recurring: {interval: 'month'},
+        metadata: {key: 'dos'},
+      )
+
+      response = Stripe::Price.search({query: 'active:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Price.search({query: 'currency:"gbp"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Price.search({query: 'lookup_key:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Price.search({query: %(product:"#{product.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id, two.id])
+
+      response = Stripe::Price.search({query: 'type:"recurring"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Price.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
+      11.times do
+        stripe_helper.create_price(product: product_id)
+      end
+
+      response = Stripe::Price.search({query: %(product:"#{product.id}")}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Price.search({query: %(product:"#{product.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::Price.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Price.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Price.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `prices`./)
+    end
+  end
 
   describe "Validations", :live => true do
     include_context "stripe validator"

data/spec/shared_stripe_examples/product_examples.rb

@@ -85,6 +85,74 @@ shared_examples "Product API" do
     expect(all.count).to eq(100)
   end
 
+  context "searching products" do
+    # the Search API requires about a minute between writes and reads, so add sleeps accordingly when running live
+    it "searches products for exact matches", :aggregate_failures do
+      response = Stripe::Product.search({query: 'name:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(0)
+
+      one = stripe_helper.create_product(
+        id: "product_1",
+        name: "one",
+        description: "un",
+        shippable: true,
+        url: "http://example.com/one",
+        metadata: {key: "uno"},
+      )
+      two = stripe_helper.create_product(
+        id: "product_2",
+        name: "two",
+        active: false,
+        description: "deux",
+        url: "http://example.com/two",
+        metadata: {key: "dos"},
+      )
+
+      response = Stripe::Product.search({query: 'active:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Product.search({query: 'description:"deux"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Product.search({query: 'name:"one"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Product.search({query: 'shippable:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([one.id])
+
+      response = Stripe::Product.search({query: 'url:"http://example.com/two"'}, stripe_version: '2020-08-27')
+      expect(response.data.map(&:id)).to match_array([two.id])
+
+      response = Stripe::Product.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
+      11.times do |i|
+        stripe_helper.create_product(id: "product_#{i}", name: "Product #{i}")
+      end
+
+      response = Stripe::Product.search({query: 'active:"true"'}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(10)
+      response = Stripe::Product.search({query: 'active:"true"', limit: 1}, stripe_version: '2020-08-27')
+      expect(response.data.size).to eq(1)
+    end
+
+    it "reports search errors", :aggregate_failures do
+      expect {
+        Stripe::Product.search({limit: 1}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Missing required param: query./)
+
+      expect {
+        Stripe::Product.search({query: 'asdf'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /We were unable to parse your search query./)
+
+      expect {
+        Stripe::Product.search({query: 'foo:"bar"'}, stripe_version: '2020-08-27')
+      }.to raise_error(Stripe::InvalidRequestError, /Field `foo` is an unsupported search field for resource `products`./)
+    end
+  end
+
   describe "Validation", :live => true do
     include_context "stripe validator"
     let(:params) { stripe_helper.create_product_params }