stripe-ruby-mock 1.10.1.1 → 1.10.1.2

data/README.md

@@ -8,7 +8,7 @@
 
 In your gemfile:
 
-    gem 'stripe-ruby-mock', '>= 1.10.1.1'
+    gem 'stripe-ruby-mock', '~> 1.10.2'
 
 ## Features
 

data/lib/stripe_mock.rb

@@ -29,6 +29,10 @@ require 'stripe_mock/api/webhooks'
 require 'stripe_mock/api/strict'
 require 'stripe_mock/api/debug'
 
+require 'stripe_mock/request_handlers/helpers/card_helpers.rb'
+require 'stripe_mock/request_handlers/helpers/subscription_helpers.rb'
+require 'stripe_mock/request_handlers/helpers/token_helpers.rb'
+
 require 'stripe_mock/request_handlers/charges.rb'
 require 'stripe_mock/request_handlers/cards.rb'
 require 'stripe_mock/request_handlers/customers.rb'

data/lib/stripe_mock/api/webhooks.rb

@@ -19,9 +19,9 @@ module StripeMock
     json.delete(:id)
 
     if @state == 'local'
-      event_data = instance.generate_event(json)
+      event_data = instance.generate_webhook_event(json)
     elsif @state == 'remote'
-      event_data = client.generate_event(json)
+      event_data = client.generate_webhook_event(json)
     else
       raise UnstartedStateError
     end

data/lib/stripe_mock/client.rb

@@ -56,8 +56,8 @@ module StripeMock
       timeout_wrap { @pipe.generate_card_token(card_params) }
     end
 
-    def generate_event(event_data)
-      timeout_wrap { Stripe::Util.symbolize_names @pipe.generate_event(event_data) }
+    def generate_webhook_event(event_data)
+      timeout_wrap { Stripe::Util.symbolize_names @pipe.generate_webhook_event(event_data) }
     end
 
     def clear_server_data

data/lib/stripe_mock/data.rb

@@ -146,6 +146,7 @@ module StripeMock
     #FIXME nested overrides would be better than hardcoding plan_id
     def self.mock_subscription(params={})
       StripeMock::Util.rmerge({
+        :current_period_start => 1308595038,
         :current_period_end => 1308681468,
         :status => "trialing",
         :plan => {
@@ -155,7 +156,6 @@ module StripeMock
           :object => "plan",
           :id => '__test_plan_id__'
         },
-        :current_period_start => 1308595038,
         :cancel_at_period_end => false,
         :canceled_at => nil,
         :ended_at => nil,
@@ -168,43 +168,74 @@ module StripeMock
       }, params)
     end
 
-    def self.mock_invoice(params={})
+    def self.mock_invoice(lines, params={})
+      in_id = params[:id] || "test_in_default"
+      lines << Data.mock_line_item() if lines.empty?
       {
-        :id => 'in_test_invoice',
-        :object => 'invoice',
-        :livemode => false,
-        :amount_due => 1000,
-        :attempt_count => 0,
-        :attempted => false,
-        :closed => false,
-        :currency => 'usd',
-        :customer => 'c_test_customer',
-        :date => 1349738950,
-        :lines => {
-          "invoiceitems" => [
-            {
-              :id => 'ii_test_invoice_item',
-              :object => '',
-              :livemode => false,
-              :amount => 1000,
-              :currency => 'usd',
-              :customer => 'c_test_customer',
-              :date => 1349738950,
-              :description => "A Test Invoice Item",
-              :invoice => 'in_test_invoice'
-            },
-          ],
+        id: 'in_test_invoice',
+        date: 1349738950,
+        period_end: 1349738950,
+        period_start: 1349738950,
+        lines: {
+          object: "list",
+          count: lines.count,
+          url: "/v1/invoices/#{in_id}/lines",
+          data: lines
+        },
+        subtotal: lines.map {|line| line[:amount]}.reduce(0, :+),
+        total: lines.map {|line| line[:amount]}.reduce(0, :+),
+        customer: "test_customer",
+        object: 'invoice',
+        attempted: false,
+        closed: false,
+        paid: false,
+        livemode: false,
+        attempt_count: 0,
+        amount_due: lines.map {|line| line[:amount]}.reduce(0, :+),
+        currency: 'usd',
+        starting_balance: 0,
+        ending_balance: nil,
+        next_payment_attempt: 1349825350,
+        charge: nil,
+        discount: nil,
+        subscription: nil
+      }.merge(params)
+    end
+
+    def self.mock_line_item(params = {})
+      {
+        id: "ii_test",
+        object: "line_item",
+        type: "invoiceitem",
+        livemode: false,
+        amount: 1000,
+        currency: "usd",
+        proration: false,
+        period: {
+          start: 1349738920,
+          end: 1349738920
         },
-        :paid => false,
-        :period_end => 1349738950,
-        :period_start => 1349738950,
-        :starting_balance => 0,
-        :subtotal => 1000,
-        :total => 1000,
-        :charge => nil,
-        :discount => nil,
-        :ending_balance => nil,
-        :next_payemnt_attempt => 1349825350,
+        quantity: nil,
+        plan: nil,
+        description: "Test invoice item",
+        metadata: {}
+      }.merge(params)
+    end
+
+    def self.mock_invoice_item(params = {})
+      {
+        id: "ii_test",
+        object: "invoiceitem",
+        date: 1349738920,
+        amount: 1099,
+        livemode: false,
+        proration: false,
+        currency: "usd",
+        customer: "cus_test",
+        description: "invoice item desc",
+        metadata: {},
+        invoice: nil,
+        subscription: nil
       }.merge(params)
     end
 

data/lib/stripe_mock/instance.rb

@@ -1,6 +1,8 @@
 module StripeMock
   class Instance
 
+    include StripeMock::RequestHandlers::Helpers
+
     # Handlers are ordered by priority
     @@handlers = []
 
@@ -80,79 +82,11 @@ module StripeMock
       end
     end
 
-    def generate_bank_token(bank_params)
-      token = new_id 'btok'
-      @bank_tokens[token] = Data.mock_bank_account bank_params
-      token
-    end
-
-    def generate_card_token(card_params)
-      token = new_id 'tok'
-      card_params[:id] = new_id 'cc'
-      @card_tokens[token] = Data.mock_card symbolize_names(card_params)
-      token
-    end
-
-    def generate_event(event_data)
+    def generate_webhook_event(event_data)
       event_data[:id] ||= new_id 'evt'
       @events[ event_data[:id] ] = symbolize_names(event_data)
     end
 
-    def get_bank_by_token(token)
-      if token.nil? || @bank_tokens[token].nil?
-        Data.mock_bank_account
-      else
-        @bank_tokens.delete(token)
-      end
-    end
-
-    def get_card_by_token(token)
-      if token.nil? || @card_tokens[token].nil?
-        Data.mock_card :id => new_id('cc')
-      else
-        @card_tokens.delete(token)
-      end
-    end
-
-    def get_customer_card(customer, token)
-      customer[:cards][:data].find{|cc| cc[:id] == token }
-    end
-
-    def add_card_to_customer(card, cus)
-      card[:customer] = cus[:id]
-
-      if cus[:cards][:count] == 0
-        cus[:cards][:count] += 1
-      else
-        cus[:cards][:data].delete_if {|card| card[:id] == cus[:default_card]}
-      end
-
-      cus[:cards][:data] << card
-
-      card
-    end
-
-    def get_customer_subscription(customer, sub_id)
-      customer[:subscriptions][:data].find{|sub| sub[:id] == sub_id }
-    end
-
-    def add_subscription_to_customer(plan, cus)
-      params = { id: new_id('su'), plan: plan, customer: cus[:id] }
-
-      if plan[:trial_period_days].nil?
-        params.merge!({status: 'active', trial_start: nil, trial_end: nil})
-      else
-        params.merge!({status: 'trialing', trial_start: Time.now.to_i, trial_end: (Time.now + plan[:trial_period_days]).to_i })
-      end
-
-      subscription = Data.mock_subscription params
-
-      cus[:subscriptions] = Data.mock_subscriptions_array(url: "/v1/customers/#{cus[:id]}/subscriptions") unless cus[:subscriptions]
-      cus[:subscriptions][:count] = (cus[:subscriptions][:count] ? cus[:subscriptions][:count]+1 : 1 )
-      cus[:subscriptions][:data] << subscription
-      subscription
-    end
-
     private
 
     def assert_existance(type, id, obj, message=nil)

data/lib/stripe_mock/request_handlers/helpers/card_helpers.rb

@@ -0,0 +1,25 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def get_customer_card(customer, token)
+        customer[:cards][:data].find{|cc| cc[:id] == token }
+      end
+
+      def add_card_to_customer(card, cus)
+        card[:customer] = cus[:id]
+
+        if cus[:cards][:count] == 0
+          cus[:cards][:count] += 1
+        else
+          cus[:cards][:data].delete_if {|card| card[:id] == cus[:default_card]}
+        end
+
+        cus[:cards][:data] << card
+
+        card
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/helpers/subscription_helpers.rb

@@ -0,0 +1,44 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def get_customer_subscription(customer, sub_id)
+        customer[:subscriptions][:data].find{|sub| sub[:id] == sub_id }
+      end
+
+      def add_subscription_to_customer(plan, cus, start_time = nil)
+        start_time ||= Time.now.utc.to_i
+        params = { id: new_id('su'), plan: plan, customer: cus[:id], current_period_start: start_time, current_period_end: get_ending_time(start_time, plan) }
+
+        if plan[:trial_period_days].nil?
+          params.merge!({status: 'active', trial_start: nil, trial_end: nil})
+        else
+          params.merge!({status: 'trialing', trial_start: Time.now.utc.to_i, trial_end: (Time.now.utc.to_i + plan[:trial_period_days]*86400) })
+        end
+
+        subscription = Data.mock_subscription params
+
+        cus[:subscriptions] = Data.mock_subscriptions_array(url: "/v1/customers/#{cus[:id]}/subscriptions") unless cus[:subscriptions]
+        cus[:subscriptions][:count] = (cus[:subscriptions][:count] ? cus[:subscriptions][:count]+1 : 1 )
+        cus[:subscriptions][:data] << subscription
+        subscription
+      end
+
+      # intervals variable is set to 1 when calculating current_period_end from current_period_start & plan
+      # intervals variable is set to 2 when calculating Stripe::Invoice.upcoming end from current_period_start & plan
+      def get_ending_time(start_time, plan, intervals = 1)
+        case plan[:interval]
+          when "week"
+            start_time + (604800 * (plan[:interval_count] || 1) * intervals)
+          when "month"
+            (Time.at(start_time).to_datetime >> ((plan[:interval_count] || 1) * intervals)).to_time.to_i
+          when "year"
+            (Time.at(start_time).to_datetime >> (12 * intervals)).to_time.to_i # max period is 1 year
+          else
+            start_time
+        end
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/helpers/token_helpers.rb

@@ -0,0 +1,36 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def generate_bank_token(bank_params)
+        token = new_id 'btok'
+        @bank_tokens[token] = Data.mock_bank_account bank_params
+        token
+      end
+
+      def generate_card_token(card_params)
+        token = new_id 'tok'
+        card_params[:id] = new_id 'cc'
+        @card_tokens[token] = Data.mock_card symbolize_names(card_params)
+        token
+      end
+
+      def get_bank_by_token(token)
+        if token.nil? || @bank_tokens[token].nil?
+          Data.mock_bank_account
+        else
+          @bank_tokens.delete(token)
+        end
+      end
+
+      def get_card_by_token(token)
+        if token.nil? || @card_tokens[token].nil?
+          Data.mock_card :id => new_id('cc')
+        else
+          @card_tokens.delete(token)
+        end
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/invoice_items.rb

@@ -7,7 +7,7 @@ module StripeMock
       end
 
       def new_invoice_item(route, method_url, params, headers)
-        Data.mock_invoice(params)
+        Data.mock_invoice_item(params)
       end
 
     end

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -4,6 +4,7 @@ module StripeMock
 
       def Invoices.included(klass)
         klass.add_handler 'post /v1/invoices',               :new_invoice
+        klass.add_handler 'get /v1/invoices/upcoming',       :upcoming_invoice
         klass.add_handler 'get /v1/invoices/(.*)',           :get_invoice
         klass.add_handler 'get /v1/invoices',                :list_invoices
         klass.add_handler 'post /v1/invoices/(.*)/pay',      :pay_invoice
@@ -11,7 +12,8 @@ module StripeMock
 
       def new_invoice(route, method_url, params, headers)
         id = new_id('in')
-        invoices[id] = Data.mock_invoice(params.merge :id => id)
+        invoice_item = Data.mock_line_item()
+        invoices[id] = Data.mock_invoice([invoice_item], params.merge(:id => id))
       end
 
       def list_invoices(route, method_url, params, headers)
@@ -30,16 +32,51 @@ module StripeMock
       def get_invoice(route, method_url, params, headers)
         route =~ method_url
         assert_existance :invoice, $1, invoices[$1]
-        invoices[$1] ||= Data.mock_invoice(:id => $1)
+        invoices[$1] ||= Data.mock_invoice([], :id => $1)
       end
-      
+
       def pay_invoice(route, method_url, params, headers)
         route =~ method_url
         assert_existance :invoice, $1, invoices[$1]
-        invoices[$1] ||= Data.mock_invoice(:id => $1)
+        invoices[$1] ||= Data.mock_invoice([], :id => $1)
         invoices[$1].merge!(:paid => true, :attempted => true, :charge => 'ch_1fD6uiR9FAA2zc')
       end
 
+      def upcoming_invoice(route, method_url, params, headers)
+        route =~ method_url
+        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, 400) if params[:customer].nil?
+
+        customer = customers[params[:customer]]
+        assert_existance :customer, params[:customer], customer
+        customer ||= Data.mock_customer([], :id => params[:customer])
+
+        raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, 404) if customer[:subscriptions][:data].length == 0
+
+        most_recent = customer[:subscriptions][:data].min_by { |sub| sub[:current_period_end] }
+        invoice_item = get_mock_subscription_line_item(most_recent)
+
+        Data.mock_invoice([invoice_item],
+          subscription: most_recent[:id],
+          period_start: most_recent[:current_period_start],
+          period_end: most_recent[:current_period_end],
+          next_payment_attempt: most_recent[:current_period_end] + 3600 )
+      end
+
+      private
+
+      def get_mock_subscription_line_item(subscription)
+        Data.mock_line_item(
+          id: subscription[:id],
+          type: "subscription",
+          plan: subscription[:plan],
+          amount: subscription[:plan][:amount],
+          quantity: 1,
+          period: {
+            start: subscription[:current_period_end],
+            end: get_ending_time(subscription[:current_period_start], subscription[:plan], 2)
+          })
+      end
+
     end
   end
 end

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -22,7 +22,7 @@ module StripeMock
         # Ensure customer has card to charge if plan has no trial and is not free
         verify_card_present(customer, plan)
 
-        subscription = add_subscription_to_customer(plan, customer)
+        subscription = add_subscription_to_customer(plan, customer, params[:current_period_start])
 
         # oddly, subscription returned from 'create_subscription' does not expand plan
         subscription.merge(plan: params[:plan])
@@ -95,13 +95,13 @@ module StripeMock
         subscription = get_customer_subscription(customer, $2)
         assert_existance :subscription, $2, subscription
 
-        cancel_params = { canceled_at: Time.now.to_i }
+        cancel_params = { canceled_at: Time.now.utc.to_i }
         if params[:at_period_end] == true
           cancel_params[:cancel_at_period_end] = true
         else
           cancel_params[:status] = "canceled"
           cancel_params[:cancel_at_period_end] = false
-          cancel_params[:ended_at] = Time.now.to_i
+          cancel_params[:ended_at] = Time.now.utc.to_i
         end
 
         subscription.merge!(cancel_params)

data/lib/stripe_mock/server.rb

@@ -55,8 +55,8 @@ module StripeMock
       @instance.generate_bank_token(recipient_params)
     end
 
-    def generate_event(event_data)
-      @instance.generate_event(event_data)
+    def generate_webhook_event(event_data)
+      @instance.generate_webhook_event(event_data)
     end
 
     def debug?; @instance.debug; end

data/lib/stripe_mock/version.rb

@@ -1,4 +1,4 @@
 module StripeMock
   # stripe-ruby-mock version
-  VERSION = "1.10.1.1"
+  VERSION = "1.10.1.2"
 end

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -56,15 +56,157 @@ shared_examples 'Invoice API' do
       @invoice = Stripe::Invoice.create
       @invoice.pay
     end
-    
+
     it 'updates attempted and paid flags' do
       expect(@invoice.attempted).to be_true
       expect(@invoice.paid).to be_true
     end
-    
+
     it 'sets the charge attribute' do
       expect(@invoice.charge).to be_a String
-      expect(@invoice.charge.length).to be > 0 
+      expect(@invoice.charge.length).to be > 0
+    end
+  end
+
+  context "retrieving upcoming invoice" do
+    before do
+      @customer = Stripe::Customer.create(email: 'johnny@appleseed.com', card: 'some_card_token')
+    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 in strict mode' 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 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
+
+    it 'works when customer has a subscription' do
+      @plan = Stripe::Plan.create()
+      @subscription = @customer.subscriptions.create(plan: @plan.id)
+      @upcoming = Stripe::Invoice.upcoming(customer: @customer.id)
+
+      expect(@upcoming).to be_a Stripe::Invoice
+      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
+      expect(Time.at(@upcoming.period_end).to_datetime >> 1).to eq(Time.at(@upcoming.lines.data[0].period.end).to_datetime) # +1 month
+      expect(@upcoming.next_payment_attempt).to eq(@upcoming.period_end + 3600) # +1 hour
+      expect(@upcoming.subscription).to eq(@subscription.id)
+    end
+
+    it 'sets the start and end of billing periods correctly when plan has an interval_count' do
+      @oddplan = Stripe::Plan.create(interval: "week", interval_count: 11)
+      @subscription = @customer.subscriptions.create(plan: @oddplan.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)
+      expect(@upcoming.period_end + 6652800).to eq(@upcoming.lines.data[0].period.end) # 6652800 = +11 weeks
+      expect(@upcoming.next_payment_attempt).to eq(@upcoming.period_end + 3600) # +1 hour
+    end
+
+    it 'chooses the most recent of multiple subscriptions' do
+      @shortplan = Stripe::Plan.create(interval: "week") # 1 week sub
+      @plainplan = Stripe::Plan.create()                 # 1 month sub
+      @longplan  = Stripe::Plan.create(interval: "year") # 1 year sub
+
+      @plainsub = @customer.subscriptions.create(plan: @plainplan.id)
+      @shortsub = @customer.subscriptions.create(plan: @shortplan.id)
+      @longsub  = @customer.subscriptions.create(plan: @longplan.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
+
+    context 'calculates month and year offsets correctly' do
+
+      it 'for one month plan on the 1st' do
+        @plan = Stripe::Plan.create()
+        @sub = @customer.subscriptions.create(plan: @plan.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))
+        expect(Time.at(@upcoming.lines.data[0].period.start)).to eq(Time.utc(2014,2,1,12))
+        expect(Time.at(@upcoming.lines.data[0].period.end)).to   eq(Time.utc(2014,3,1,12))
+      end
+
+      it 'for one year plan on the 1st' do
+        @plan = Stripe::Plan.create(interval: "year")
+        @sub = @customer.subscriptions.create(plan: @plan.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))
+        expect(Time.at(@upcoming.lines.data[0].period.start)).to eq(Time.utc(2013,1,1,12))
+        expect(Time.at(@upcoming.lines.data[0].period.end)).to   eq(Time.utc(2014,1,1,12))
+      end
+
+      it 'for one month plan on the 31st' do
+        @plan = Stripe::Plan.create()
+        @sub = @customer.subscriptions.create(plan: @plan.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))
+        expect(Time.at(@upcoming.lines.data[0].period.start)).to eq(Time.utc(2014,2,28,12))
+        expect(Time.at(@upcoming.lines.data[0].period.end)).to   eq(Time.utc(2014,3,31,12))
+      end
+
+      it 'for one year plan on feb. 29th' do
+        @plan = Stripe::Plan.create(interval: "year")
+        @sub = @customer.subscriptions.create(plan: @plan.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))
+        expect(Time.at(@upcoming.lines.data[0].period.start)).to eq(Time.utc(2013,2,28,12))
+        expect(Time.at(@upcoming.lines.data[0].period.end)).to   eq(Time.utc(2014,2,28,12))
+      end
+
+      it 'for two month plan on dec. 31st' do
+        @plan = Stripe::Plan.create(interval_count: 2)
+        @sub = @customer.subscriptions.create(plan: @plan.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))
+        expect(Time.at(@upcoming.lines.data[0].period.start)).to eq(Time.utc(2014, 2,28,12))
+        expect(Time.at(@upcoming.lines.data[0].period.end)).to   eq(Time.utc(2014, 4,30,12))
+      end
+
+      it 'for three month plan on nov. 30th' do
+        @plan = Stripe::Plan.create(interval_count: 3)
+        @sub = @customer.subscriptions.create(plan: @plan.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))
+        expect(Time.at(@upcoming.lines.data[0].period.start)).to eq(Time.utc(2014, 2,28,12))
+        expect(Time.at(@upcoming.lines.data[0].period.end)).to   eq(Time.utc(2014, 5,30,12))
+      end
+    end
+
   end
 end

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -84,6 +84,7 @@ shared_examples 'Customer Subscriptions' do
 
       expect(sub.object).to eq('subscription')
       expect(sub.plan).to eq('trial')
+      expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
 
       customer = Stripe::Customer.retrieve('cardless')
       expect(customer.subscriptions.data).to_not be_empty

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stripe-ruby-mock
 version: !ruby/object:Gem::Version
-  version: 1.10.1.1
+  version: 1.10.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-24 00:00:00.000000000 Z
+date: 2014-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: stripe
@@ -148,6 +148,9 @@ files:
 - lib/stripe_mock/request_handlers/coupons.rb
 - lib/stripe_mock/request_handlers/customers.rb
 - lib/stripe_mock/request_handlers/events.rb
+- lib/stripe_mock/request_handlers/helpers/card_helpers.rb
+- lib/stripe_mock/request_handlers/helpers/subscription_helpers.rb
+- lib/stripe_mock/request_handlers/helpers/token_helpers.rb
 - lib/stripe_mock/request_handlers/invoice_items.rb
 - lib/stripe_mock/request_handlers/invoices.rb
 - lib/stripe_mock/request_handlers/plans.rb