stripe-ruby-mock 2.4.1 → 2.5.0

data/spec/shared_stripe_examples/dispute_examples.rb

@@ -18,7 +18,7 @@ shared_examples 'Dispute API' do
     dispute_id = 'dp_05RsQX2eZvKYlo2C0FRTGSSA'
     dispute = Stripe::Dispute.retrieve(dispute_id)
 
-    expect(dispute).to be_a(Stripe::Dispute) 
+    expect(dispute).to be_a(Stripe::Dispute)
     expect(dispute.id).to eq(dispute_id)
   end
 
@@ -36,7 +36,7 @@ shared_examples 'Dispute API' do
       :customer_name => 'Rebel Idealist',
       :product_description => 'Lorem ipsum dolor sit amet.',
       :shipping_documentation => 'fil_15BZxW2eZvKYlo2CvQbrn9dc',
-    }    
+    }
     dispute.save
 
     dispute = Stripe::Dispute.retrieve(dispute_id)
@@ -50,13 +50,13 @@ shared_examples 'Dispute API' do
 
   it "closes a dispute" do
     dispute_id = 'dp_75RsQX2eZvKYlo2C0EDCXSWQ'
-    
+
     dispute = Stripe::Dispute.retrieve(dispute_id)
-    
+
     expect(dispute).to be_a(Stripe::Dispute)
     expect(dispute.id).to eq(dispute_id)
     expect(dispute.status).to eq('under_review')
-    
+
     dispute.close
 
     dispute = Stripe::Dispute.retrieve(dispute_id)
@@ -67,7 +67,7 @@ shared_examples 'Dispute API' do
   end
 
   describe "listing disputes" do
-    
+
     it "retrieves all disputes" do
       disputes = Stripe::Dispute.all
 
@@ -79,9 +79,10 @@ shared_examples 'Dispute API' do
       disputes = Stripe::Dispute.all(limit: 3)
 
       expect(disputes.count).to eq(3)
-      expect(disputes.map &:id).to include('dp_95RsQX2eZvKYlo2C0EDFRYUI','dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ')
+      expected = ['dp_95RsQX2eZvKYlo2C0EDFRYUI','dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ']
+      expect(disputes.map &:id).to include(*expected)
     end
 
   end
-  
+
 end

data/spec/shared_stripe_examples/error_mock_examples.rb

@@ -12,7 +12,7 @@ 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', 444, 'body', 'json body')
+    error = Stripe::CardError.new('Test Msg', 'param_name', 'bad_code', http_status: 444, http_body: 'body', json_body: 'json body')
     StripeMock.prepare_error(error)
 
     expect { Stripe::Customer.create() }.to raise_error {|e|
@@ -30,7 +30,7 @@ shared_examples 'Stripe Error Mocking' do
 
   it "mocks a manually gives stripe invalid request error" do
 
-    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', 987, 'ibody', 'json ibody')
+    error = Stripe::InvalidRequestError.new('Test Invalid', 'param', http_status: 987, http_body: 'ibody', json_body: 'json ibody')
     StripeMock.prepare_error(error)
 
     expect { Stripe::Charge.create(amount: 1, currency: 'usd') }.to raise_error {|e|
@@ -46,7 +46,7 @@ shared_examples 'Stripe Error Mocking' do
 
 
   it "mocks a manually gives stripe invalid auth error" do
-    error = Stripe::AuthenticationError.new('Bad Auth', 499, 'abody', 'json abody')
+    error = Stripe::AuthenticationError.new('Bad Auth', http_status: 499, http_body: 'abody', json_body: 'json abody')
     StripeMock.prepare_error(error)
 
     expect { stripe_helper.create_plan() }.to raise_error {|e|

data/spec/shared_stripe_examples/extra_features_examples.rb

@@ -8,6 +8,7 @@ shared_examples 'Extra Features' do
 
     customer = Stripe::Customer.create
     expect(customer.id).to match /^custom_prefix_cus/
+    StripeMock.global_id_prefix = nil
   end
 
   it "can set the global id prefix to nothing" do
@@ -23,6 +24,7 @@ shared_examples 'Extra Features' do
 
     customer = Stripe::Customer.create
     expect(customer.id).to match /^cus/
+    StripeMock.global_id_prefix = nil
   end
 
   it "has a default global id prefix" do

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -107,42 +107,80 @@ shared_examples 'Invoice API' do
   end
 
   context "retrieving upcoming invoice" do
-    before do
-      @customer = Stripe::Customer.create(email: 'johnny@appleseed.com', source: stripe_helper.generate_card_token)
-    end
+    let(:customer)      { @teardown_customer = true; Stripe::Customer.create(source: stripe_helper.generate_card_token) }
+    let(:coupon_amtoff) { @teardown_coupon_amtoff = true; Stripe::Coupon.create(id: '100OFF', currency: 'usd', amount_off: 100_00, duration: 'repeating', duration_in_months: 6) }
+    let(:coupon_pctoff) { @teardown_coupon_pctoff = true; Stripe::Coupon.create(id: '50%OFF', currency: 'usd', percent_off: 50, duration: 'repeating', duration_in_months: 6) }
+    let(:plan)          { @teardown_plan = true; Stripe::Plan.create(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
+    let(:quantity)      { 3 }
+    let(:subscription)  { @teardown_subscription = true; Stripe::Subscription.create(plan: plan.id, customer: customer.id, quantity: quantity) }
+
+    before(with_customer:         true) { customer }
+    before(with_coupon_amtoff:    true) { coupon_amtoff }
+    before(with_coupon_pctoff:    true) { coupon_pctoff }
+    before(with_discount_amtoff:  true) { customer.coupon = coupon_amtoff.id; customer.save }
+    before(with_discount_pctoff:  true) { customer.coupon = coupon_pctoff.id; customer.save }
+    before(with_plan:             true) { plan }
+    before(with_subscription:     true) { subscription }
+
+    after { subscription.delete   rescue nil if @teardown_subscription }
+    after { plan.delete           rescue nil if @teardown_plan }
+    after { coupon_pctoff.delete  rescue nil if @teardown_coupon_pctoff }
+    after { coupon_amtoff.delete  rescue nil if @teardown_coupon_amtoff }
+    after { customer.delete       rescue nil if @teardown_customer }
+
+    describe 'parameter validation' do
+      it 'fails without parameters' do
+        expect { Stripe::Invoice.upcoming() }.to raise_error {|e|
+          expect(e).to be_a(ArgumentError) }
+      end
 
-    it 'fails without parameters' do
-      expect { Stripe::Invoice.upcoming() }.to raise_error {|e|
-        expect(e).to be_a(ArgumentError) }
-    end
+      it 'fails without a valid customer' do
+        expect { Stripe::Invoice.upcoming(customer: 'whatever') }.to raise_error {|e|
+          expect(e).to be_a(Stripe::InvalidRequestError)
+          expect(e.message).to eq('No such customer: whatever') }
+      end
 
-    it 'fails without a valid customer' do
-      expect { Stripe::Invoice.upcoming(customer: 'whatever') }.to raise_error {|e|
-        expect(e).to be_a(Stripe::InvalidRequestError)
-        expect(e.message).to eq('No such customer: whatever') }
-    end
+      it 'fails without a customer parameter' 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') }
+      end
 
-    it 'fails without a customer parameter' 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') }
+      it 'fails without a subscription' do
+        expect { Stripe::Invoice.upcoming(customer: customer.id) }.to raise_error {|e|
+          expect(e).to be_a(Stripe::InvalidRequestError)
+          expect(e.http_status).to eq(404)
+          expect(e.message).to eq("No upcoming invoices for customer: #{customer.id}") }
+      end
     end
 
-    it 'fails without a subscription' do
-      expect { Stripe::Invoice.upcoming(customer: @customer.id) }.to raise_error {|e|
-        expect(e).to be_a(Stripe::InvalidRequestError)
-        expect(e.http_status).to eq(404)
-        expect(e.message).to eq("No upcoming invoices for customer: #{@customer.id}") }
+    describe 'parameter validation' do
+      it 'fails without a subscription or subscription plan if subscription proration date is specified', live: true do
+        expect { Stripe::Invoice.upcoming(customer: customer.id, subscription_proration_date: Time.now.to_i) }.to raise_error do |e|
+          expect(e).to be_a Stripe::InvalidRequestError
+          expect(e.http_status).to eq 400
+          expect(e.message).to eq 'When previewing changes to a subscription, you must specify either `subscription` or `subscription_items`'
+        end
+      end
+
+      it 'fails without a subscription if proration date is specified', live: true, with_subscription: true do
+        expect { Stripe::Invoice.upcoming(customer: customer.id, subscription_plan: plan.id, subscription_proration_date: Time.now.to_i) }.to raise_error do |e|
+          expect(e).to be_a Stripe::InvalidRequestError
+          expect(e.http_status).to eq 400
+          expect(e.message).to eq 'Cannot specify proration date without specifying a subscription'
+        end
+      end
     end
 
-    it 'works when customer has a subscription', :live => true do
-      plan = stripe_helper.create_plan(:id => 'has_sub')
-      subscription = Stripe::Subscription.create(plan: plan.id, customer: @customer.id)
-      upcoming = Stripe::Invoice.upcoming(customer: @customer.id)
+    it 'considers current subscription', live: true, with_subscription: true do
+      # When
+      upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
+      # Then
       expect(upcoming).to be_a Stripe::Invoice
-      expect(upcoming.customer).to eq(@customer.id)
+      expect(upcoming.customer).to eq(customer.id)
+      expect(upcoming.amount_due).to eq plan.amount * quantity
       expect(upcoming.total).to eq(upcoming.lines.data[0].amount)
       expect(upcoming.period_end).to eq(upcoming.lines.data[0].period.start)
       expect(Time.at(upcoming.period_start).to_datetime >> 1).to eq(Time.at(upcoming.period_end).to_datetime) # +1 month
@@ -151,10 +189,156 @@ shared_examples 'Invoice API' do
       expect(upcoming.subscription).to eq(subscription.id)
     end
 
+    describe 'discounts' do
+      it 'considers a $ off discount', live: true, with_discount_amtoff: true, with_subscription: true do
+        # When
+        upcoming = Stripe::Invoice.upcoming(customer: customer.id)
+
+        # Then
+        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.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
+      end
+
+      it 'considers a % off discount', live: true, with_discount_pctoff: true, with_subscription: true do
+        # When
+        upcoming = Stripe::Invoice.upcoming(customer: customer.id)
+
+        # Then
+        expect(upcoming.discount).not_to be_nil
+        expect(upcoming.discount.coupon.id).to eq '50%OFF'
+        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.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
+      end
+    end
+
+    describe 'proration' do
+      shared_examples 'failing when proration date is outside of the subscription current period' do
+        it 'fails', live: true do
+          expect { Stripe::Invoice.upcoming(
+              customer: customer.id,
+              subscription: subscription.id,
+              subscription_plan: plan.id,
+              subscription_quantity: quantity,
+              subscription_proration_date: proration_date.to_i,
+              subscription_trial_end: nil
+          ) }.to raise_error {|e|
+            expect(e).to be_a(Stripe::InvalidRequestError)
+            expect(e.http_status).to eq(400)
+            expect(e.message).to eq('Cannot specify proration date outside of current subscription period') }
+        end
+      end
+
+      it_behaves_like 'failing when proration date is outside of the subscription current period' do
+        let(:proration_date) { subscription.current_period_start - 1 }
+      end
+
+      it_behaves_like 'failing when proration date is outside of the subscription current period' do
+        let(:proration_date) { subscription.current_period_end + 1 }
+      end
+
+      [false, true].each do |with_trial|
+        describe "prorating a subscription with a new plan, with_trial: #{with_trial}" do
+          let!(:new_plan) { Stripe::Plan.create(id: '100y', amount: 10000, interval: 'year', name: '100y', currency: 'usd') }
+
+          it 'prorates', live: true 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)
+            prorated_amount_due = new_plan.amount * new_quantity - unused_amount
+            credit_balance = 1000
+            customer.account_balance = -credit_balance
+            customer.save
+            query = { customer: customer.id, subscription: subscription.id, subscription_plan: new_plan.id, subscription_proration_date: proration_date.to_i, subscription_quantity: new_quantity }
+            query[:subscription_trial_end] = (DateTime.now >> 1).to_time.to_i if with_trial
+
+            # When
+            upcoming = Stripe::Invoice.upcoming(query)
+
+            # Then
+            expect(upcoming).to be_a Stripe::Invoice
+            expect(upcoming.customer).to eq(customer.id)
+            if with_trial
+              expect(upcoming.amount_due).to eq 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)
+            expect(upcoming.lines.data[0].proration).to be_truthy
+            expect(upcoming.lines.data[0].plan.id).to eq '50m'
+            expect(upcoming.lines.data[0].amount).to be_within(1).of -unused_amount
+            expect(upcoming.lines.data[0].quantity).to eq quantity
+            expect(upcoming.lines.data[1].proration).to be_falsey
+            expect(upcoming.lines.data[1].plan.id).to eq '100y'
+            expect(upcoming.lines.data[1].amount).to eq with_trial ? 0 : 20000
+            expect(upcoming.lines.data[1].quantity).to eq new_quantity
+          end
+
+          after { new_plan.delete }
+        end
+      end
+
+      shared_examples 'no proration is done' 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.date).to be_within(1).of subscription.current_period_end
+          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
+          line = preview.lines.first
+          expect(line.type).to eq 'subscription'
+          expect(line.amount).to eq 150_00
+          # line period is for the NEXT subscription cycle
+          expect(line.period.start).to be_within(1).of subscription.current_period_end
+          expect(line.period.end).to be_within(1).of (Time.at(subscription.current_period_end).to_datetime >> 1).to_time.to_i # +1 month
+        end
+      end
+
+      describe 'upcoming invoice with no proration parameters specified' do
+        let(:preview) do
+          Stripe::Invoice.upcoming(
+              customer: customer.id,
+              subscription: subscription.id
+          )
+        end
+
+        it_behaves_like 'no proration is done'
+      end
+
+      describe 'upcoming invoice with same subscription plan and quantity specified' do
+        let(:preview) do
+          proration_date = Time.now + 60
+          Stripe::Invoice.upcoming(
+              customer: customer.id,
+              subscription: subscription.id,
+              subscription_plan: plan.id,
+              subscription_quantity: quantity,
+              subscription_proration_date: proration_date.to_i,
+              subscription_trial_end: nil
+          )
+        end
+
+        it_behaves_like 'no proration is done'
+      end
+    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)
-      @subscription = Stripe::Subscription.create(plan: @oddplan.id, customer: @customer.id)
-      @upcoming = Stripe::Invoice.upcoming(customer: @customer.id)
+      @subscription = Stripe::Subscription.create(plan: @oddplan.id, customer: customer.id)
+      @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
       expect(@upcoming.period_start + 6652800).to eq(@upcoming.period_end) # 6652800 = +11 weeks
       expect(@upcoming.period_end).to eq(@upcoming.lines.data[0].period.start)
@@ -167,11 +351,11 @@ shared_examples 'Invoice API' do
       @plainplan = stripe_helper.create_plan(id: 'b')                 # 1 month sub
       @longplan  = stripe_helper.create_plan(id: 'c', 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)
-      @longsub  = Stripe::Subscription.create(plan: @longplan.id, customer: @customer.id)
+      @plainsub = Stripe::Subscription.create(plan: @plainplan.id, customer: customer.id)
+      @shortsub = Stripe::Subscription.create(plan: @shortplan.id, customer: customer.id)
+      @longsub  = Stripe::Subscription.create(plan: @longplan.id, customer: customer.id)
 
-      @upcoming = Stripe::Invoice.upcoming(customer: @customer.id)
+      @upcoming = Stripe::Invoice.upcoming(customer: customer.id)
 
       expect(@upcoming.period_start + 604800).to eq(@upcoming.period_end) # 604800 = 1 week
       expect(@upcoming.period_end + 604800).to eq(@upcoming.lines.data[0].period.end) # 604800 = 1 week
@@ -180,7 +364,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)
+        invoice = Stripe::Invoice.create(customer: customer.id)
         line_items = invoice.lines.all
 
         expect(invoice).to be_a Stripe::Invoice
@@ -192,8 +376,8 @@ shared_examples 'Invoice API' do
 
       it 'returns all line items for upcoming invoice' do
         plan = stripe_helper.create_plan()
-        subscription = Stripe::Subscription.create(plan: plan.id, customer: @customer.id)
-        upcoming = Stripe::Invoice.upcoming(customer: @customer.id)
+        subscription = Stripe::Subscription.create(plan: plan.id, customer: customer.id)
+        upcoming = Stripe::Invoice.upcoming(customer: customer.id)
         line_items = upcoming.lines.all
 
         expect(upcoming).to be_a Stripe::Invoice
@@ -208,8 +392,8 @@ shared_examples 'Invoice API' do
 
       it 'for one month plan on the 1st' do
         @plan = stripe_helper.create_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)
+        @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)
 
         expect(Time.at(@upcoming.period_start)).to               eq(Time.utc(2014,1,1,12))
         expect(Time.at(@upcoming.period_end)).to                 eq(Time.utc(2014,2,1,12))
@@ -219,8 +403,8 @@ shared_examples 'Invoice API' do
 
       it 'for one year plan on the 1st' do
         @plan = stripe_helper.create_plan(interval: "year")
-        @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)
+        @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)
 
         expect(Time.at(@upcoming.period_start)).to               eq(Time.utc(2012,1,1,12))
         expect(Time.at(@upcoming.period_end)).to                 eq(Time.utc(2013,1,1,12))
@@ -230,8 +414,8 @@ shared_examples 'Invoice API' do
 
       it 'for one month plan on the 31st' do
         @plan = stripe_helper.create_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)
+        @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)
 
         expect(Time.at(@upcoming.period_start)).to               eq(Time.utc(2014,1,31,12))
         expect(Time.at(@upcoming.period_end)).to                 eq(Time.utc(2014,2,28,12))
@@ -241,8 +425,8 @@ shared_examples 'Invoice API' do
 
       it 'for one year plan on feb. 29th' do
         @plan = stripe_helper.create_plan(interval: "year")
-        @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)
+        @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)
 
         expect(Time.at(@upcoming.period_start)).to               eq(Time.utc(2012,2,29,12))
         expect(Time.at(@upcoming.period_end)).to                 eq(Time.utc(2013,2,28,12))
@@ -252,8 +436,8 @@ shared_examples 'Invoice API' do
 
       it 'for two month plan on dec. 31st' do
         @plan = stripe_helper.create_plan(interval_count: 2)
-        @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)
+        @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)
 
         expect(Time.at(@upcoming.period_start)).to               eq(Time.utc(2013,12,31,12))
         expect(Time.at(@upcoming.period_end)).to                 eq(Time.utc(2014, 2,28,12))
@@ -263,8 +447,8 @@ shared_examples 'Invoice API' do
 
       it 'for three month plan on nov. 30th' do
         @plan = stripe_helper.create_plan(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)
+        @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)
 
         expect(Time.at(@upcoming.period_start)).to               eq(Time.utc(2013,11,30,12))
         expect(Time.at(@upcoming.period_end)).to                 eq(Time.utc(2014, 2,28,12))