stripe-ruby-mock 2.4.0 → 2.5.8

data/lib/stripe_mock/request_handlers/accounts.rb

@@ -1,6 +1,7 @@
 module StripeMock
   module RequestHandlers
     module Accounts
+      VALID_START_YEAR = 2009
 
       def Accounts.included(klass)
         klass.add_handler 'post /v1/accounts',      :new_account
@@ -26,8 +27,14 @@ module StripeMock
 
       def update_account(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :account, $1, accounts[$1]
-        accounts[$1].merge!(params)
+        account = assert_existence :account, $1, accounts[$1]
+        account.merge!(params)
+        if blank_value?(params[:tos_acceptance], :date)
+          raise Stripe::InvalidRequestError.new("Invalid integer: ", "tos_acceptance[date]", http_status: 400)
+        elsif params[:tos_acceptance] && params[:tos_acceptance][:date]
+          validate_acceptance_date(params[:tos_acceptance][:date])
+        end
+        account
       end
 
       def list_accounts(route, method_url, params, headers)
@@ -49,6 +56,31 @@ module StripeMock
           accounts[acc[:id]] = acc
         end
       end
+
+      # Checks if setting a blank value
+      #
+      # returns true if the key is included in the hash
+      # and its value is empty or nil
+      def blank_value?(hash, key)
+        if hash.key?(key)
+          value = hash[key]
+          return true if value.nil? || "" == value
+        end
+        false
+      end
+
+      def validate_acceptance_date(unix_date)
+        unix_now = Time.now.strftime("%s").to_i
+        formatted_date = Time.at(unix_date)
+
+        return if formatted_date.year >= VALID_START_YEAR && unix_now >= unix_date
+
+        raise Stripe::InvalidRequestError.new(
+          "ToS acceptance date is not valid. Dates are expected to be integers, measured in seconds, not in the future, and after 2009",
+          "tos_acceptance[date]", 
+          http_status: 400
+        )
+      end
     end
   end
 end

data/lib/stripe_mock/request_handlers/balance.rb

@@ -0,0 +1,17 @@
+module StripeMock
+  module RequestHandlers
+    module Balance
+
+      def Balance.included(klass)
+        klass.add_handler 'get /v1/balance',                        :get_balance
+      end
+
+      def get_balance(route, method_url, params, headers)
+        route =~ method_url
+
+        return_balance = Data.mock_balance(account_balance)
+        return_balance
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/balance_transactions.rb

@@ -9,11 +9,27 @@ module StripeMock
 
       def get_balance_transaction(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :balance_transaction, $1, balance_transactions[$1]
+        assert_existence :balance_transaction, $1, hide_additional_attributes(balance_transactions[$1])
       end
 
       def list_balance_transactions(route, method_url, params, headers)
-        Data.mock_list_object(balance_transactions.values, params)
+        values = balance_transactions.values
+        if params.has_key?(:transfer)
+          # If transfer supplied as params, need to filter the btxns returned to only include those with the specified transfer id
+          values = values.select{|btxn| btxn[:transfer] == params[:transfer]}
+        end
+        Data.mock_list_object(values.map{|btxn| hide_additional_attributes(btxn)}, params)
+      end
+
+      private
+
+      def hide_additional_attributes(btxn)
+        # For automatic Stripe transfers, the transfer attribute on balance_transaction stores the transfer which
+        # included this balance_transaction.  However, it is not exposed as a field returned on a balance_transaction.
+        # Therefore, need to not show this attribute if it exists.
+        if !btxn.nil?
+          btxn.reject{|k,v| k == :transfer }
+        end
       end
 
     end

data/lib/stripe_mock/request_handlers/charges.rb

@@ -13,9 +13,12 @@ module StripeMock
       end
 
       def new_charge(route, method_url, params, headers)
-        if params[:idempotency_key] && charges.any?
-          original_charge = charges.values.find { |c| c[:idempotency_key] == params[:idempotency_key]}
-          return charges[original_charge[:id]] if original_charge
+        if headers && headers[:idempotency_key]
+          params[:idempotency_key] = headers[:idempotency_key]
+          if charges.any?
+            original_charge = charges.values.find { |c| c[:idempotency_key] == headers[:idempotency_key]}
+            return charges[original_charge[:id]] if original_charge
+          end
         end
 
         id = new_id('ch')
@@ -31,7 +34,7 @@ module StripeMock
               params[:source] = get_card_or_bank_by_token(params[:source])
             end
           elsif params[:source][:id]
-            raise Stripe::InvalidRequestError.new("Invalid token id: #{params[:source]}", 'card', 400)
+            raise Stripe::InvalidRequestError.new("Invalid token id: #{params[:source]}", 'card', http_status: 400)
           end
         elsif params[:customer]
           customer = customers[params[:customer]]
@@ -41,7 +44,7 @@ module StripeMock
         end
 
         ensure_required_params(params)
-        bal_trans_params = { amount: params[:amount], source: params[:source] }
+        bal_trans_params = { amount: params[:amount], source: id, application_fee: params[:application_fee] }
 
         balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
 
@@ -49,12 +52,13 @@ module StripeMock
             params.merge :id => id,
             :balance_transaction => balance_transaction_id)
 
+        charge = charges[id].clone
         if params[:expand] == ['balance_transaction']
-          charges[id][:balance_transaction] =
+          charge[:balance_transaction] =
             balance_transactions[balance_transaction_id]
         end
 
-        charges[id]
+        charge
       end
 
       def update_charge(route, method_url, params, headers)
@@ -65,7 +69,7 @@ module StripeMock
         allowed = allowed_params(params)
         disallowed = params.keys - allowed
         if disallowed.count > 0
-          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', 400)
+          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', http_status: 400)
         end
 
         charges[id] = Util.rmerge(charge, params)
@@ -87,7 +91,15 @@ module StripeMock
       def get_charge(route, method_url, params, headers)
         route =~ method_url
         charge_id = $1 || params[:charge]
-        assert_existence :charge, charge_id, charges[charge_id]
+        charge = assert_existence :charge, charge_id, charges[charge_id]
+
+        charge = charge.clone
+        if params[:expand] == ['balance_transaction']
+          balance_transaction = balance_transactions[charge[:balance_transaction]]
+          charge[:balance_transaction] = balance_transaction
+        end
+
+        charge
       end
 
       def capture_charge(route, method_url, params, headers)
@@ -130,11 +142,11 @@ module StripeMock
         elsif params[:currency].nil?
           require_param(:currency)
         elsif non_integer_charge_amount?(params)
-          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', 400)
+          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
         elsif non_positive_charge_amount?(params)
-          raise Stripe::InvalidRequestError.new('Invalid positive integer', 'amount', 400)
+          raise Stripe::InvalidRequestError.new('Invalid positive integer', 'amount', http_status: 400)
         elsif params[:source].nil? && params[:customer].nil?
-          raise Stripe::InvalidRequestError.new('Must provide source or customer.', nil)
+          raise Stripe::InvalidRequestError.new('Must provide source or customer.', http_status: nil)
         end
       end
 
@@ -146,12 +158,8 @@ module StripeMock
         params[:amount] && params[:amount] < 1
       end
 
-      def require_param(param)
-        raise Stripe::InvalidRequestError.new("Missing required param: #{param}", param.to_s, 400)
-      end
-
       def allowed_params(params)
-        allowed = [:description, :metadata, :receipt_email, :fraud_details, :shipping]
+        allowed = [:description, :metadata, :receipt_email, :fraud_details, :shipping, :destination]
 
         # This is a workaround for the way the Stripe API sends params even when they aren't modified.
         # Stipe will include those params even when they aren't modified.

data/lib/stripe_mock/request_handlers/coupons.rb

@@ -11,18 +11,19 @@ module StripeMock
 
       def new_coupon(route, method_url, params, headers)
         params[:id] ||= new_id('coupon')
-        raise Stripe::InvalidRequestError.new('Missing required param: duration', 'coupon', 400) unless params[:duration]
-        coupons[ params[:id] ] = Data.mock_coupon(params)
+        raise Stripe::InvalidRequestError.new('Missing required param: duration', 'coupon', http_status: 400) unless params[:duration]
+        raise Stripe::InvalidRequestError.new('You must pass currency when passing amount_off', 'coupon', http_status: 400) if params[:amount_off] && !params[:currency]
+        coupons[ params[:id] ] = Data.mock_coupon({amount_off: nil, percent_off:nil}.merge(params))
       end
 
       def get_coupon(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :id, $1, coupons[$1]
+        assert_existence :coupon, $1, coupons[$1]
       end
 
       def delete_coupon(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :id, $1, coupons.delete($1)
+        assert_existence :coupon, $1, coupons.delete($1)
       end
 
       def list_coupons(route, method_url, params, headers)

data/lib/stripe_mock/request_handlers/customers.rb

@@ -8,6 +8,7 @@ module StripeMock
         klass.add_handler 'get /v1/customers/([^/]*)',              :get_customer
         klass.add_handler 'delete /v1/customers/([^/]*)',           :delete_customer
         klass.add_handler 'get /v1/customers',                      :list_customers
+        klass.add_handler 'delete /v1/customers/([^/]*)/discount',  :delete_customer_discount
       end
 
       def new_customer(route, method_url, params, headers)
@@ -18,7 +19,7 @@ module StripeMock
           new_card =
             if params[:source].is_a?(Hash)
               unless params[:source][:object] && params[:source][:number] && params[:source][:exp_month] && params[:source][:exp_year]
-                raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, 400)
+                raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
               end
               card_from_params(params[:source])
             else
@@ -35,22 +36,22 @@ module StripeMock
           plan = assert_existence :plan, plan_id, plans[plan_id]
 
           if params[:default_source].nil? && params[:trial_end].nil? && plan[:trial_period_days].nil? && plan[:amount] != 0
-            raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, 400)
+            raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
           end
 
           subscription = Data.mock_subscription({ id: new_id('su') })
-          subscription.merge!(custom_subscription_params(plan, customers[ params[:id] ], params))
+          subscription = resolve_subscription_changes(subscription, [plan], customers[ params[:id] ], params)
           add_subscription_to_customer(customers[ params[:id] ], subscription)
           subscriptions[subscription[:id]] = subscription
         elsif params[:trial_end]
-          raise Stripe::InvalidRequestError.new('Received unknown parameter: trial_end', nil, 400)
+          raise Stripe::InvalidRequestError.new('Received unknown parameter: trial_end', nil, http_status: 400)
         end
 
         if params[:coupon]
           coupon = coupons[ params[:coupon] ]
           assert_existence :coupon, params[:coupon], coupon
 
-          add_coupon_to_customer(customers[params[:id]], coupon)
+          add_coupon_to_object(customers[params[:id]], coupon)
         end
 
         customers[ params[:id] ]
@@ -77,7 +78,7 @@ module StripeMock
             new_card = get_card_or_bank_by_token(params.delete(:source))
           elsif params[:source].is_a?(Hash)
             unless params[:source][:object] && params[:source][:number] && params[:source][:exp_month] && params[:source][:exp_year]
-              raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, 400)
+              raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
             end
             new_card = card_from_params(params.delete(:source))
           end
@@ -89,7 +90,7 @@ module StripeMock
           coupon = coupons[ params[:coupon] ]
           assert_existence :coupon, params[:coupon], coupon
 
-          add_coupon_to_customer(cus, coupon)
+          add_coupon_to_object(cus, coupon)
         end
 
         cus
@@ -107,13 +108,30 @@ module StripeMock
 
       def get_customer(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[$1]
+
+        customer = customer.clone
+        if params[:expand] == ['default_source']
+          customer[:default_source] = customer[:sources][:data].detect do |source|
+            source[:id] == customer[:default_source]
+          end
+        end
+
+        customer
       end
 
       def list_customers(route, method_url, params, headers)
         Data.mock_list_object(customers.values, params)
       end
 
+      def delete_customer_discount(route, method_url, params, headers)
+        route =~ method_url
+        cus = assert_existence :customer, $1, customers[$1]
+
+        cus[:discount] = nil
+
+        cus
+      end
     end
   end
 end

data/lib/stripe_mock/request_handlers/ephemeral_key.rb

@@ -0,0 +1,13 @@
+module StripeMock
+  module RequestHandlers
+    module EphemeralKey
+      def self.included(klass)
+        klass.add_handler 'post /v1/ephemeral_keys', :create_ephemeral_key
+      end
+
+      def create_ephemeral_key(route, method_url, params, headers)
+        Data.mock_ephemeral_key(params)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/external_accounts.rb

@@ -0,0 +1,55 @@
+module StripeMock
+  module RequestHandlers
+    module ExternalAccounts
+
+      def ExternalAccounts.included(klass)
+        klass.add_handler 'get /v1/accounts/(.*)/external_accounts', :retrieve_external_accounts
+        klass.add_handler 'post /v1/accounts/(.*)/external_accounts', :create_external_account
+        klass.add_handler 'post /v1/accounts/(.*)/external_accounts/(.*)/verify', :verify_external_account
+        klass.add_handler 'get /v1/accounts/(.*)/external_accounts/(.*)', :retrieve_external_account
+        klass.add_handler 'delete /v1/accounts/(.*)/external_accounts/(.*)', :delete_external_account
+        klass.add_handler 'post /v1/accounts/(.*)/external_accounts/(.*)', :update_external_account
+      end
+
+      def create_external_account(route, method_url, params, headers)
+        route =~ method_url
+        add_external_account_to(:account, $1, params, accounts)
+      end
+
+      def retrieve_external_accounts(route, method_url, params, headers)
+        route =~ method_url
+        retrieve_object_cards(:account, $1, accounts)
+      end
+
+      def retrieve_external_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+
+        assert_existence :card, $2, get_card(account, $2)
+      end
+
+      def delete_external_account(route, method_url, params, headers)
+        route =~ method_url
+        delete_card_from(:account, $1, $2, accounts)
+      end
+
+      def update_external_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+
+        card = assert_existence :card, $2, get_card(account, $2)
+        card.merge!(params)
+        card
+      end
+
+      def verify_external_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+
+        external_account = assert_existence :bank_account, $2, verify_bank_account(account, $2)
+        external_account
+      end
+
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module StripeMock
     module Helpers
 
       def verify_bank_account(object, bank_account_id, class_name='Customer')
-        bank_accounts = object[:bank_accounts] || object[:sources]
+        bank_accounts = object[:external_accounts] || object[:bank_accounts] || object[:sources]
         bank_account = bank_accounts[:data].find{|acc| acc[:id] == bank_account_id }
         return if bank_account.nil?
         bank_account['status'] = 'verified'

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

@@ -3,15 +3,15 @@ module StripeMock
     module Helpers
 
       def get_card(object, card_id, class_name='Customer')
-        cards = object[:cards] || object[:sources]
+        cards = object[:cards] || object[:sources] || object[:external_accounts]
         card = cards[:data].find{|cc| cc[:id] == card_id }
         if card.nil?
           if class_name == 'Recipient'
             msg = "#{class_name} #{object[:id]} does not have a card with ID #{card_id}"
-            raise Stripe::InvalidRequestError.new(msg, 'card', 404)
+            raise Stripe::InvalidRequestError.new(msg, 'card', http_status: 404)
           else
             msg = "There is no source with ID #{card_id}"
-            raise Stripe::InvalidRequestError.new(msg, 'id', 404)
+            raise Stripe::InvalidRequestError.new(msg, 'id', http_status: 404)
           end
         end
         card
@@ -36,7 +36,7 @@ module StripeMock
 
       def add_card_to_object(type, card, object, replace_current=false)
         card[type] = object[:id]
-        cards_or_sources = object[:cards] || object[:sources]
+        cards_or_sources = object[:cards] || object[:sources] || object[:external_accounts]
 
         is_customer = object.has_key?(:sources)
 
@@ -58,7 +58,7 @@ module StripeMock
 
       def retrieve_object_cards(type, type_id, objects)
         resource = assert_existence type, type_id, objects[type_id]
-        cards = resource[:cards] || resource[:sources]
+        cards = resource[:cards] || resource[:sources] || resource[:external_accounts]
 
         Data.mock_list_object(cards[:data])
       end
@@ -69,7 +69,7 @@ module StripeMock
         assert_existence :card, card_id, get_card(resource, card_id)
 
         card = { id: card_id, deleted: true }
-        cards_or_sources = resource[:cards] || resource[:sources]
+        cards_or_sources = resource[:cards] || resource[:sources] || resource[:external_accounts]
         cards_or_sources[:data].reject!{|cc|
           cc[:id] == card[:id]
         }
@@ -77,6 +77,7 @@ module StripeMock
         is_customer = resource.has_key?(:sources)
         new_default = cards_or_sources[:data].count > 0 ? cards_or_sources[:data].first[:id] : nil
         resource[:default_card]   = new_default unless is_customer
+        resource[:sources][:total_count] = cards_or_sources[:data].count if is_customer
         resource[:default_source] = new_default if is_customer
         card
       end
@@ -96,13 +97,14 @@ module StripeMock
               get_bank_by_token(params[:source])
             end
           end
+        source[:metadata].merge!(params[:metadata]) if params[:metadata]
         add_source_to_object(type, source, resource)
       end
 
       def add_card_to(type, type_id, params, objects)
         resource = assert_existence type, type_id, objects[type_id]
 
-        card = card_from_params(params[:card] || params[:source])
+        card = card_from_params(params[:card] || params[:source] || params[:external_accounts])
         add_card_to_object(type, card, resource)
       end
 

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

@@ -1,13 +1,17 @@
 module StripeMock
   module RequestHandlers
     module Helpers
+      def add_coupon_to_object(object, coupon)
+        discount_attrs = {}.tap do |attrs|
+          attrs[object[:object]]         = object[:id]
+          attrs[:coupon]                 = coupon
+          attrs[:start]                  = Time.now.to_i
+          attrs[:end]                    = (DateTime.now >> coupon[:duration_in_months].to_i).to_time.to_i if coupon[:duration] == 'repeating'
+        end
 
-      def add_coupon_to_customer(customer, coupon)
-        customer[:discount] = { coupon: coupon }
-
-        customer
+        object[:discount] = Stripe::Discount.construct_from(discount_attrs)
+        object
       end
-
     end
   end
-end
+end

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

@@ -0,0 +1,49 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def add_external_account_to(type, type_id, params, objects)
+        resource = assert_existence type, type_id, objects[type_id]
+
+        source =
+          if params[:card]
+            card_from_params(params[:card])
+          elsif params[:bank_account]
+            bank_from_params(params[:bank_account])
+          else
+            begin
+              get_card_by_token(params[:external_account])
+            rescue Stripe::InvalidRequestError
+              bank_from_params(params[:external_account])
+            end
+          end
+        add_external_account_to_object(type, source, resource)
+      end
+
+      def add_external_account_to_object(type, source, object, replace_current=false)
+        source[type] = object[:id]
+        accounts = object[:external_accounts]
+
+        if replace_current && accounts[:data]
+          accounts[:data].delete_if {|source| source[:id] == object[:default_source]}
+          object[:default_source] = source[:id]
+          accounts[:data] = [source]
+        else
+          accounts[:total_count] = (accounts[:total_count] || 0) + 1
+          (accounts[:data] ||= []) << source
+        end
+        object[:default_source] = source[:id] if object[:default_source].nil?
+
+        source
+      end
+
+      def bank_from_params(attrs_or_token)
+        if attrs_or_token.is_a? Hash
+          attrs_or_token = generate_bank_token(attrs_or_token)
+        end
+        get_bank_by_token(attrs_or_token)
+      end
+
+    end
+  end
+end

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

@@ -6,20 +6,49 @@ module StripeMock
         customer[:subscriptions][:data].find{|sub| sub[:id] == sub_id }
       end
 
-      def custom_subscription_params(plan, cus, options = {})
+      def resolve_subscription_changes(subscription, plans, customer, options = {})
+        subscription.merge!(custom_subscription_params(plans, customer, options))
+        items = options[:items]
+        items = items.values if items.respond_to?(:values)
+        subscription[:items][:data] = plans.map do |plan|
+          if items && items.size == plans.size
+            quantity = items &&
+              items.detect { |item| item[:plan] == plan[:id] }[:quantity] || 1
+            Data.mock_subscription_item({ plan: plan, quantity: quantity })
+          else
+            Data.mock_subscription_item({ plan: plan })
+          end
+        end
+        subscription
+      end
+
+      def custom_subscription_params(plans, cus, options = {})
         verify_trial_end(options[:trial_end]) if options[:trial_end]
 
-        start_time = options[:current_period_start] || Time.now.utc.to_i
-        params = { plan: plan, customer: cus[:id], current_period_start: start_time }
-        params.merge! options.select {|k,v| k =~ /application_fee_percent|quantity|metadata|tax_percent/}
+        plan = plans.first if plans.size == 1
+
+        now = Time.now.utc.to_i
+        created_time = options[:created] || now
+        start_time = options[:current_period_start] || now
+        params = { customer: cus[:id], current_period_start: start_time, created: created_time }
+        params.merge!({ :plan => (plans.size == 1 ? plans.first : nil) })
+        keys_to_merge = /application_fee_percent|quantity|metadata|tax_percent|billing|days_until_due/
+        params.merge! options.select {|k,v| k =~ keys_to_merge}
+
+        if options[:cancel_at_period_end] == true
+          params.merge!(cancel_at_period_end: true, canceled_at: now)
+        elsif options[:cancel_at_period_end] == false
+          params.merge!(cancel_at_period_end: false, canceled_at: nil)
+        end
+
         # TODO: Implement coupon logic
 
-        if (plan[:trial_period_days].nil? && options[:trial_end].nil?) || options[:trial_end] == "now"
-          end_time = get_ending_time(start_time, plan)
-          params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil})
+        if (((plan && plan[:trial_period_days]) || 0) == 0 && options[:trial_end].nil?) || options[:trial_end] == "now"
+          end_time = options[:billing_cycle_anchor] || get_ending_time(start_time, plan)
+          params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil, billing_cycle_anchor: options[:billing_cycle_anchor]})
         else
           end_time = options[:trial_end] || (Time.now.utc.to_i + plan[:trial_period_days]*86400)
-          params.merge!({status: 'trialing', current_period_end: end_time, trial_start: start_time, trial_end: end_time})
+          params.merge!({status: 'trialing', current_period_end: end_time, trial_start: start_time, trial_end: end_time, billing_cycle_anchor: nil})
         end
 
         params
@@ -28,13 +57,17 @@ module StripeMock
       def add_subscription_to_customer(cus, sub)
         if sub[:trial_end].nil? || sub[:trial_end] == "now"
           id = new_id('ch')
-          charges[id] = Data.mock_charge(:id => id, :customer => cus[:id], :amount => sub[:plan][:amount])
+          charges[id] = Data.mock_charge(
+            :id => id,
+            :customer => cus[:id],
+            :amount => (sub[:plan] ? sub[:plan][:amount] : total_items_amount(sub[:items][:data]))
+          )
         end
 
         if cus[:currency].nil?
-          cus[:currency] = sub[:plan][:currency]
-        elsif cus[:currency] != sub[:plan][:currency]
-          raise Stripe::InvalidRequestError.new( "Can't combine currencies on a single customer. This customer has had a subscription, coupon, or invoice item with currency #{cus[:currency]}", 'currency', 400)
+          cus[:currency] = sub[:items][:data][0][:plan][:currency]
+        elsif cus[:currency] != sub[:items][:data][0][:plan][:currency]
+          raise Stripe::InvalidRequestError.new( "Can't combine currencies on a single customer. This customer has had a subscription, coupon, or invoice item with currency #{cus[:currency]}", 'currency', http_status: 400)
         end
         cus[:subscriptions][:total_count] = (cus[:subscriptions][:total_count] || 0) + 1
         cus[:subscriptions][:data].unshift sub
@@ -50,6 +83,8 @@ module StripeMock
       # `intervals` is set to 1 when calculating current_period_end from current_period_start & plan
       # `intervals` is set to 2 when calculating Stripe::Invoice.upcoming end from current_period_start & plan
       def get_ending_time(start_time, plan, intervals = 1)
+        return start_time unless plan
+
         case plan[:interval]
         when "week"
           start_time + (604800 * (plan[:interval_count] || 1) * intervals)
@@ -65,15 +100,20 @@ module StripeMock
       def verify_trial_end(trial_end)
         if trial_end != "now"
           if !trial_end.is_a? Integer
-            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer', nil, 400)
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer', nil, http_status: 400)
           elsif trial_end < Time.now.utc.to_i
-            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer Unix timestamp in the future', nil, 400)
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer Unix timestamp in the future', nil, http_status: 400)
           elsif trial_end > Time.now.utc.to_i + 31557600*5 # five years
-            raise Stripe::InvalidRequestError.new('Invalid timestamp: can be no more than five years in the future', nil, 400)
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: can be no more than five years in the future', nil, http_status: 400)
           end
         end
       end
 
+      def total_items_amount(items)
+        total = 0
+        items.each { |i| total += (i[:quantity] || 1) * i[:plan][:amount] }
+        total
+      end
     end
   end
 end