stripe-ruby-mock 2.3.1 → 2.5.8

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -52,7 +52,7 @@ shared_examples 'Invoice API' do
     end
 
     it "stores all invoices in memory" do
-      expect(Stripe::Invoice.all.map(&:id)).to eq([@invoice.id, @invoice2.id])
+      expect(Stripe::Invoice.all.map(&:id).sort).to eq([@invoice.id, @invoice2.id].sort)
     end
 
     it "defaults count to 10 invoices" do
@@ -76,57 +76,111 @@ shared_examples 'Invoice API' do
   context "paying an invoice" do
     before do
       @invoice = Stripe::Invoice.create
-      @invoice.pay
     end
 
     it 'updates attempted and paid flags' do
+      @invoice = @invoice.pay
       expect(@invoice.attempted).to eq(true)
       expect(@invoice.paid).to eq(true)
     end
 
+    it 'creates a new charge object' do
+      expect{ @invoice.pay }.to change { Stripe::Charge.list.data.count }.by 1
+    end
+
     it 'sets the charge attribute' do
+      @invoice = @invoice.pay
       expect(@invoice.charge).to be_a String
       expect(@invoice.charge.length).to be > 0
     end
+
+    it 'charges the invoice customers default card' do
+      customer = Stripe::Customer.create({
+        source: stripe_helper.generate_card_token
+      })
+      customer_invoice = Stripe::Invoice.create({customer: customer})
+
+      customer_invoice.pay
+
+      expect(Stripe::Charge.list.data.first.customer).to eq customer.id
+    end
   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)      { 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(:quantity)      { 3 }
+    let(:subscription)  { 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
@@ -135,10 +189,213 @@ 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_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') }
+
+          it 'prorates while maintaining billing interval', 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)
+            remaining_amount = new_monthly_plan.amount * new_quantity * (subscription.current_period_end - proration_date.to_i) / (subscription.current_period_end - subscription.current_period_start)
+            prorated_amount_due = new_monthly_plan.amount * new_quantity - unused_amount + remaining_amount
+            credit_balance = 1000
+            customer.account_balance = -credit_balance
+            customer.save
+            query = { customer: customer.id, subscription: subscription.id, subscription_plan: new_monthly_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 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.lines.data.length).to eq(2)
+            else
+              expect(upcoming.lines.data.length).to eq(3)
+            end
+
+            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
+
+            unless with_trial
+              expect(upcoming.lines.data[1].proration).to be_truthy
+              expect(upcoming.lines.data[1].plan.id).to eq '100m'
+              expect(upcoming.lines.data[1].amount).to be_within(1).of remaining_amount
+              expect(upcoming.lines.data[1].quantity).to eq new_quantity
+            end
+
+            expect(upcoming.lines.data.last.proration).to be_falsey
+            expect(upcoming.lines.data.last.plan.id).to eq '100m'
+            expect(upcoming.lines.data.last.amount).to eq with_trial ? 0 : 20000
+            expect(upcoming.lines.data.last.quantity).to eq new_quantity
+          end
+
+          it 'prorates while changing billing intervals', 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_yearly_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_yearly_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_monthly_plan.delete rescue nil if @teardown_monthly_plan }
+          # after { new_yearly_plan.delete rescue nil if @teardown_yearly_plan }
+        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.created).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(Time.at(line.period.end).month).to be_within(1).of (Time.at(subscription.current_period_end).to_datetime >> 1).month # +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)
@@ -151,20 +408,26 @@ 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
       expect(@upcoming.subscription).to eq(@shortsub.id)
     end
 
+    it 'does not store the stripe invoice in memory since its only a preview', with_subscription: true do
+      invoice = Stripe::Invoice.upcoming(customer: customer.id)
+      data = test_data_source(:invoices)
+      expect(data[invoice.id]).to be_nil
+    end
+
     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
@@ -176,9 +439,9 @@ 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)
-        line_items = upcoming.lines.all
+        subscription = Stripe::Subscription.create(plan: plan.id, customer: customer.id)
+        upcoming = Stripe::Invoice.upcoming(customer: customer.id)
+        line_items = upcoming.lines
 
         expect(upcoming).to be_a Stripe::Invoice
         expect(line_items.count).to eq(1)
@@ -192,8 +455,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))
@@ -203,8 +466,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))
@@ -214,8 +477,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))
@@ -225,8 +488,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))
@@ -236,8 +499,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))
@@ -247,8 +510,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))

data/spec/shared_stripe_examples/payout_examples.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+shared_examples 'Payout API' do
+
+  it "creates a stripe payout" do
+    payout = Stripe::Payout.create(amount:  "100", currency: "usd")
+
+    expect(payout.id).to match(/^test_po/)
+    expect(payout.amount).to eq('100')
+    expect(payout.currency).to eq('usd')
+    expect(payout.metadata.to_hash).to eq({})
+  end
+
+  describe "listing payouts" do
+    before do
+      3.times do
+        Stripe::Payout.create(amount: "100", currency: "usd")
+      end
+    end
+
+    it "without params retrieves all tripe payouts" do
+      expect(Stripe::Payout.all.count).to eq(3)
+    end
+
+    it "accepts a limit param" do
+      expect(Stripe::Payout.all(limit: 2).count).to eq(2)
+    end
+  end
+
+  it "retrieves a stripe payout" do
+    original = Stripe::Payout.create(amount:  "100", currency: "usd")
+    payout = Stripe::Payout.retrieve(original.id)
+
+    expect(payout.id).to eq(original.id)
+    expect(payout.amount).to eq(original.amount)
+    expect(payout.currency).to eq(original.currency)
+    expect(payout.metadata.to_hash).to eq(original.metadata.to_hash)
+  end
+
+  it "cannot retrieve a payout that doesn't exist" do
+    expect { Stripe::Payout.retrieve('nope') }.to raise_error {|e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('payout')
+      expect(e.http_status).to eq(404)
+    }
+  end
+
+  it 'when amount is not integer', live: true do
+    expect { Stripe::Payout.create(amount: '400.2',
+                                       currency: 'usd',
+                                       description: 'Payout for test@example.com') }.to raise_error { |e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('amount')
+      expect(e.http_status).to eq(400)
+    }
+  end
+
+  it 'when amount is negative', live: true do
+    expect { Stripe::Payout.create(amount: '-400',
+                                     currency: 'usd',
+                                     description: 'Payout for test@example.com') }.to raise_error { |e|
+      expect(e).to be_a Stripe::InvalidRequestError
+      expect(e.param).to eq('amount')
+      expect(e.message).to match(/^Invalid.*integer/)
+      expect(e.http_status).to eq(400)
+    }
+  end
+end

data/spec/shared_stripe_examples/plan_examples.rb

@@ -9,6 +9,9 @@ shared_examples 'Plan API' do
       :amount => 9900,
       :currency => 'USD',
       :interval => 1,
+      :product => {
+        :name => 'A product'
+      },
       :metadata => {
         :description => "desc text",
         :info => "info text"
@@ -30,20 +33,40 @@ shared_examples 'Plan API' do
   end
 
 
+  it "creates a stripe plan without specifying ID" do
+    plan = Stripe::Plan.create(
+      :name => 'The Mock Plan',
+      :amount => 9900,
+      :currency => 'USD',
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
+    )
+
+    expect(plan.id).to match(/^test_plan/)
+  end
+
   it "stores a created stripe plan in memory" do
     plan = Stripe::Plan.create(
       :id => 'pid_2',
       :name => 'The Memory Plan',
       :amount => 1100,
       :currency => 'USD',
-      :interval => 1
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
     )
     plan2 = Stripe::Plan.create(
       :id => 'pid_3',
       :name => 'The Bonk Plan',
       :amount => 7777,
       :currency => 'USD',
-      :interval => 1
+      :interval => 1,
+      :product => {
+        :name => 'A product'
+      }
     )
     data = test_data_source(:plans)
     expect(data[plan.id]).to_not be_nil
@@ -118,6 +141,20 @@ shared_examples 'Plan API' do
     expect(all.count).to eq(100)
   end
 
+  it 'validates the amount' do
+    expect {
+      Stripe::Plan.create(
+        :id => 'pid_1',
+        :name => 'The Mock Plan',
+        :amount => 99.99,
+        :currency => 'USD',
+        :interval => 'month',
+        :product => {
+          :name => 'A product'
+        }
+      )
+    }.to raise_error(Stripe::InvalidRequestError, "Invalid integer: 99.99")
+  end
 
   describe "Validation", :live => true do
     let(:params) { stripe_helper.create_plan_params }
@@ -126,10 +163,16 @@ shared_examples 'Plan API' do
     describe "Required Parameters" do
       after do
         params.delete(@name)
-        expect { subject }.to raise_error(Stripe::InvalidRequestError, "Missing required param: #{@name}.")
+        message =
+          if @name == :amount
+            "Plans require an `#{@name}` parameter to be set."
+          else
+            "Missing required param: #{@name}."
+          end
+        expect { subject }.to raise_error(Stripe::InvalidRequestError, message)
       end
 
-      it("requires a name") { @name = :name }
+      it("requires a product") { @name = :product }
       it("requires an amount") { @name = :amount }
       it("requires a currency") { @name = :currency }
       it("requires an interval") { @name = :interval }