stripe-ruby-mock 2.5.8 → 4.0.0

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
 

data/spec/shared_stripe_examples/express_login_link_examples.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+shared_examples 'Express Login Link API' do
+  describe 'create an Express Login Link' do
+    it 'creates a login link' do
+      account_link = Stripe::Account.create_login_link('acct_103ED82ePvKYlo2C')
+
+      expect(account_link).to be_a Stripe::LoginLink
+      expect(account_link.url).to start_with('https://connect.stripe.com/express/')
+    end
+  end
+end

data/spec/shared_stripe_examples/external_account_examples.rb

@@ -63,7 +63,7 @@ shared_examples 'External Account API' do
     let!(:bank) { account.external_accounts.create(external_account: bank_token) }
 
     it "can retrieve all account's banks" do
-      retrieved = account.external_accounts.all
+      retrieved = account.external_accounts.list
       expect(retrieved.count).to eq(1)
     end
 
@@ -142,7 +142,7 @@ shared_examples 'External Account API' do
 
       account = Stripe::Account.retrieve('test_account')
 
-      list = account.external_accounts.all
+      list = account.external_accounts.list
 
       expect(list.object).to eq("list")
       expect(list.count).to eq(2)
@@ -159,7 +159,7 @@ shared_examples 'External Account API' do
       Stripe::Account.create(id: 'no_banks', type: 'custom', country: "US")
       account = Stripe::Account.retrieve('no_banks')
 
-      list = account.external_accounts.all
+      list = account.external_accounts.list
 
       expect(list.object).to eq("list")
       expect(list.count).to eq(0)

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
@@ -48,31 +53,114 @@ shared_examples 'Invoice API' do
     end
 
     it "stores invoices for a customer in memory" do
-      expect(@customer.invoices.map(&:id)).to eq([@invoice.id])
+      invoices = Stripe::Invoice.list(customer: @customer.id)
+      expect(invoices.map(&:id)).to eq([@invoice.id])
     end
 
     it "stores all invoices in memory" do
-      expect(Stripe::Invoice.all.map(&:id).sort).to eq([@invoice.id, @invoice2.id].sort)
+      expect(Stripe::Invoice.list.map(&:id)).to match_array([@invoice.id, @invoice2.id])
     end
 
     it "defaults count to 10 invoices" do
       11.times { Stripe::Invoice.create }
-      expect(Stripe::Invoice.all.count).to eq(10)
+      expect(Stripe::Invoice.list.count).to eq(10)
     end
 
     it "is marked as having more when more objects exist" do
       11.times { Stripe::Invoice.create }
 
-      expect(Stripe::Invoice.all.has_more).to eq(true)
+      expect(Stripe::Invoice.list.has_more).to eq(true)
     end
 
     context "when passing limit" do
       it "gets that many invoices" do
-        expect(Stripe::Invoice.all(limit: 1).count).to eq(1)
+        expect(Stripe::Invoice.list(limit: 1).count).to eq(1)
       end
     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
@@ -82,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
@@ -109,8 +213,9 @@ shared_examples 'Invoice API' do
   context "retrieving upcoming invoice" do
     let(:customer)      { Stripe::Customer.create(source: stripe_helper.generate_card_token) }
     let(:coupon_amtoff) { stripe_helper.create_coupon(id: '100OFF', currency: 'usd', amount_off: 100_00, duration: 'repeating', duration_in_months: 6) }
-    let(:coupon_pctoff) { stripe_helper.create_coupon(id: '50%OFF', currency: 'usd', percent_off: 50, amount_off: nil, duration: 'repeating', duration_in_months: 6) }
-    let(:plan)          { stripe_helper.create_plan(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
+    let(:coupon_pctoff) { stripe_helper.create_coupon(id: '50OFF', currency: 'usd', percent_off: 50, amount_off: nil, duration: 'repeating', duration_in_months: 6) }
+    let(:product)       { stripe_helper.create_product(id: "prod_123") }
+    let(:plan)          { stripe_helper.create_plan(id: '50m', product: product.id, amount: 50_00, interval: 'month', nickname: '50m', currency: 'usd') }
     let(:quantity)      { 3 }
     let(:subscription)  { Stripe::Subscription.create(plan: plan.id, customer: customer.id, quantity: quantity) }
 
@@ -131,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
@@ -144,7 +252,7 @@ shared_examples 'Invoice API' do
         expect { Stripe::Invoice.upcoming(gazebo: 'raindance') }.to raise_error {|e|
           expect(e).to be_a(Stripe::InvalidRequestError)
           expect(e.http_status).to eq(400)
-          expect(e.message).to eq('Missing required param: customer') }
+          expect(e.message).to eq('Missing required param: customer if subscription is not provided') }
       end
 
       it 'fails without a subscription' do
@@ -198,8 +306,8 @@ shared_examples 'Invoice API' do
         expect(upcoming.discount).not_to be_nil
         expect(upcoming.discount.coupon.id).to eq '100OFF'
         expect(upcoming.discount.customer).to eq customer.id
-        expect(upcoming.discount.start).to be_within(5).of Time.now.to_i
-        expect(upcoming.discount.end).to be_within(5).of (Time.now.to_datetime >> 6).to_time.to_i
+        expect(upcoming.discount.start).to be_within(60).of Time.now.to_i
+        expect(upcoming.discount.end).to be_within(60).of (Time.now.to_datetime >> 6).to_time.to_i
         expect(upcoming.amount_due).to eq plan.amount * quantity - 100_00
         expect(upcoming.subtotal).to eq(upcoming.lines.data[0].amount)
         expect(upcoming.total).to eq upcoming.subtotal - 100_00
@@ -211,10 +319,10 @@ shared_examples 'Invoice API' do
 
         # Then
         expect(upcoming.discount).not_to be_nil
-        expect(upcoming.discount.coupon.id).to eq '50%OFF'
+        expect(upcoming.discount.coupon.id).to eq '50OFF'
         expect(upcoming.discount.customer).to eq customer.id
-        expect(upcoming.discount.start).to be_within(5).of Time.now.to_i
-        expect(upcoming.discount.end).to be_within(5).of (Time.now.to_datetime >> 6).to_time.to_i
+        expect(upcoming.discount.start).to be_within(60).of Time.now.to_i
+        expect(upcoming.discount.end).to be_within(60).of (Time.now.to_datetime >> 6).to_time.to_i
         expect(upcoming.amount_due).to eq (plan.amount * quantity) * 0.5
         expect(upcoming.subtotal).to eq(upcoming.lines.data[0].amount)
         expect(upcoming.total).to eq upcoming.subtotal * 0.5
@@ -223,7 +331,7 @@ shared_examples 'Invoice API' do
 
     describe 'proration' do
       shared_examples 'failing when proration date is outside of the subscription current period' do
-        it 'fails', live: true do
+        it 'fails', live: true, skip: 'Stripe does not raise error anymore' do
           expect { Stripe::Invoice.upcoming(
               customer: customer.id,
               subscription: subscription.id,
@@ -248,9 +356,9 @@ shared_examples 'Invoice API' do
 
       [false, true].each do |with_trial|
         describe "prorating a subscription with a new plan, with_trial: #{with_trial}" do
-          let(:new_monthly_plan) { stripe_helper.create_plan(id: '100m', amount: 100_00, interval: 'month', name: '100m', currency: 'usd') }
-          let(:new_yearly_plan) { stripe_helper.create_plan(id: '100y', amount: 100_00, interval: 'year', name: '100y', currency: 'usd') }
-          let(:plan) { stripe_helper.create_plan(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
+          let(:new_monthly_plan) { stripe_helper.create_plan(id: '100m', product: product.id, amount: 100_00, interval: 'month') }
+          let(:new_yearly_plan) { stripe_helper.create_plan(id: '100y', product: product.id, amount: 100_00, interval: 'year') }
+          let(:plan) { stripe_helper.create_plan(id: '50m', product: product.id, amount: 50_00, interval: 'month') }
 
           it 'prorates while maintaining billing interval', live: true do
             # Given
@@ -271,19 +379,17 @@ shared_examples 'Invoice API' do
             # Then
             expect(upcoming).to be_a Stripe::Invoice
             expect(upcoming.customer).to eq(customer.id)
-            if with_trial
-              expect(upcoming.amount_due).to be_within(1).of 0
-            else
-              expect(upcoming.amount_due).to be_within(1).of prorated_amount_due - credit_balance
-            end
             expect(upcoming.starting_balance).to eq -credit_balance
-            expect(upcoming.ending_balance).to be_nil
             expect(upcoming.subscription).to eq(subscription.id)
 
             if with_trial
+              expect(upcoming.amount_due).to be_within(1).of 0
               expect(upcoming.lines.data.length).to eq(2)
+              # expect(upcoming.ending_balance).to be_within(50).of -13540 # -13322
             else
+              expect(upcoming.amount_due).to be_within(1).of prorated_amount_due - credit_balance
               expect(upcoming.lines.data.length).to eq(3)
+              expect(upcoming.ending_balance).to eq 0
             end
 
             expect(upcoming.lines.data[0].proration).to be_truthy
@@ -308,9 +414,10 @@ shared_examples 'Invoice API' do
             # Given
             proration_date = Time.now + 5 * 24 * 3600 # 5 days later
             new_quantity = 2
-            unused_amount = plan.amount * quantity * (subscription.current_period_end - proration_date.to_i) / (subscription.current_period_end - subscription.current_period_start)
+            unused_amount = (plan.amount.to_f * quantity * (subscription.current_period_end - proration_date.to_i) / (subscription.current_period_end - subscription.current_period_start)).round
             prorated_amount_due = new_yearly_plan.amount * new_quantity - unused_amount
             credit_balance = 1000
+            amount_due = prorated_amount_due - credit_balance
             customer.account_balance = -credit_balance
             customer.save
             query = { customer: customer.id, subscription: subscription.id, subscription_plan: new_yearly_plan.id, subscription_proration_date: proration_date.to_i, subscription_quantity: new_quantity }
@@ -323,12 +430,13 @@ shared_examples 'Invoice API' do
             expect(upcoming).to be_a Stripe::Invoice
             expect(upcoming.customer).to eq(customer.id)
             if with_trial
+              # expect(upcoming.ending_balance).to be_within(50).of -13540 # -13322
               expect(upcoming.amount_due).to eq 0
             else
-              expect(upcoming.amount_due).to be_within(1).of prorated_amount_due - credit_balance
+              expect(upcoming.ending_balance).to eq 0
+              expect(upcoming.amount_due).to be_within(1).of amount_due
             end
             expect(upcoming.starting_balance).to eq -credit_balance
-            expect(upcoming.ending_balance).to be_nil
             expect(upcoming.subscription).to eq(subscription.id)
 
             expect(upcoming.lines.data[0].proration).to be_truthy
@@ -351,7 +459,7 @@ shared_examples 'Invoice API' do
         it 'generates a preview without performing an actual proration', live: true do
           expect(preview.subtotal).to eq 150_00
           # this is a future invoice (generted at the end of the current subscription cycle), rather than a proration invoice
-          expect(preview.created).to be_within(1).of subscription.current_period_end
+          expect(preview.due_date).to be_nil
           expect(preview.period_start).to eq subscription.current_period_start
           expect(preview.period_end).to eq subscription.current_period_end
           expect(preview.lines.count).to eq 1
@@ -393,7 +501,7 @@ shared_examples 'Invoice API' do
     end
 
     it 'sets the start and end of billing periods correctly when plan has an interval_count' do
-      @oddplan = stripe_helper.create_plan(interval: "week", interval_count: 11)
+      @oddplan = stripe_helper.create_plan(product: product.id, interval: "week", interval_count: 11, id: "weekly_pl")
       @subscription = Stripe::Subscription.create(plan: @oddplan.id, customer: customer.id)
       @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -404,9 +512,9 @@ shared_examples 'Invoice API' do
     end
 
     it 'chooses the most recent of multiple subscriptions' do
-      @shortplan = stripe_helper.create_plan(id: 'a', interval: "week") # 1 week sub
-      @plainplan = stripe_helper.create_plan(id: 'b')                 # 1 month sub
-      @longplan  = stripe_helper.create_plan(id: 'c', interval: "year") # 1 year sub
+      @shortplan = stripe_helper.create_plan(id: 'a', product: product.id, interval: "week") # 1 week sub
+      @plainplan = stripe_helper.create_plan(id: 'b', product: product.id, interval: "month") # 1 month sub
+      @longplan  = stripe_helper.create_plan(id: 'c', product: product.id, interval: "year") # 1 year sub
 
       @plainsub = Stripe::Subscription.create(plan: @plainplan.id, customer: customer.id)
       @shortsub = Stripe::Subscription.create(plan: @shortplan.id, customer: customer.id)
@@ -428,7 +536,7 @@ shared_examples 'Invoice API' do
     context 'retrieving invoice line items' do
       it 'returns all line items for created invoice' do
         invoice = Stripe::Invoice.create(customer: customer.id)
-        line_items = invoice.lines.all
+        line_items = invoice.lines.list
 
         expect(invoice).to be_a Stripe::Invoice
         expect(line_items.count).to eq(1)
@@ -438,7 +546,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'returns all line items for upcoming invoice' do
-        plan = stripe_helper.create_plan()
+        plan = stripe_helper.create_plan(product: product.id, id: "silver_pl")
         subscription = Stripe::Subscription.create(plan: plan.id, customer: customer.id)
         upcoming = Stripe::Invoice.upcoming(customer: customer.id)
         line_items = upcoming.lines
@@ -454,7 +562,7 @@ shared_examples 'Invoice API' do
     context 'calculates month and year offsets correctly' do
 
       it 'for one month plan on the 1st' do
-        @plan = stripe_helper.create_plan()
+        @plan = stripe_helper.create_plan(product: product.id, id: "one_mo_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2014,1,1,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -465,7 +573,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for one year plan on the 1st' do
-        @plan = stripe_helper.create_plan(interval: "year")
+        @plan = stripe_helper.create_plan(interval: "year", product: product.id, id: "year_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2012,1,1,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -476,7 +584,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for one month plan on the 31st' do
-        @plan = stripe_helper.create_plan()
+        @plan = stripe_helper.create_plan(product: product.id, id: "one_mo_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2014,1,31,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -487,7 +595,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for one year plan on feb. 29th' do
-        @plan = stripe_helper.create_plan(interval: "year")
+        @plan = stripe_helper.create_plan(product: product.id, interval: "year", id: "year_plan")
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2012,2,29,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -498,7 +606,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for two month plan on dec. 31st' do
-        @plan = stripe_helper.create_plan(interval_count: 2)
+        @plan = stripe_helper.create_plan(product: product.id, interval_count: 2, id: 'two_mo_plan')
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2013,12,31,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
@@ -509,7 +617,7 @@ shared_examples 'Invoice API' do
       end
 
       it 'for three month plan on nov. 30th' do
-        @plan = stripe_helper.create_plan(interval_count: 3)
+        @plan = stripe_helper.create_plan(product: product.id, interval_count: 3)
         @sub = Stripe::Subscription.create(plan: @plan.id, customer: customer.id, current_period_start: Time.utc(2013,11,30,12).to_i)
         @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 

data/spec/shared_stripe_examples/invoice_item_examples.rb

@@ -39,7 +39,7 @@ shared_examples 'Invoice Item API' do
     end
 
     it "retrieves all invoice items" do
-      all = Stripe::InvoiceItem.all
+      all = Stripe::InvoiceItem.list
       expect(all.count).to eq(2)
       expect(all.map &:amount).to include(1075, 1540)
     end