stripe-ruby-mock 2.4.0 → 2.5.8

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

@@ -28,7 +28,7 @@ module StripeMock
         if token.nil? || @card_tokens[token].nil?
           # TODO: Make this strict
           msg = "Invalid token id: #{token}"
-          raise Stripe::InvalidRequestError.new(msg, 'tok', 404)
+          raise Stripe::InvalidRequestError.new(msg, 'tok', http_status: 404)
         else
           @card_tokens.delete(token)
         end
@@ -36,7 +36,7 @@ module StripeMock
 
       def get_card_or_bank_by_token(token)
         token_id = token['id'] || token
-         @card_tokens[token_id] || @bank_tokens[token_id] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token_id}", 'tok', 404))
+         @card_tokens[token_id] || @bank_tokens[token_id] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token_id}", 'tok', http_status: 404))
       end
 
     end

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -52,29 +52,98 @@ module StripeMock
       def pay_invoice(route, method_url, params, headers)
         route =~ method_url
         assert_existence :invoice, $1, invoices[$1]
-        invoices[$1].merge!(:paid => true, :attempted => true, :charge => 'ch_1fD6uiR9FAA2zc')
+        charge = invoice_charge(invoices[$1])
+        invoices[$1].merge!(:paid => true, :attempted => true, :charge => charge[:id])
       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?
+        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, http_status: 400) if params[:customer].nil?
+        raise Stripe::InvalidRequestError.new('When previewing changes to a subscription, you must specify either `subscription` or `subscription_items`', nil, http_status: 400) if !params[:subscription_proration_date].nil? && params[:subscription].nil? && params[:subscription_plan].nil?
+        raise Stripe::InvalidRequestError.new('Cannot specify proration date without specifying a subscription', nil, http_status: 400) if !params[:subscription_proration_date].nil? && params[:subscription].nil?
 
         customer = customers[params[:customer]]
         assert_existence :customer, params[:customer], customer
 
-        raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, 404) if customer[:subscriptions][:data].length == 0
+        raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, http_status: 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)
+        subscription =
+          if params[:subscription]
+            customer[:subscriptions][:data].select{|s|s[:id] == params[:subscription]}.first
+          else
+            customer[:subscriptions][:data].min_by { |sub| sub[:current_period_end] }
+          end
 
-        id = new_id('in')
-        invoices[id] = Data.mock_invoice([invoice_item],
-          id: id,
+        if params[:subscription_proration_date] && !((subscription[:current_period_start]..subscription[:current_period_end]) === params[:subscription_proration_date])
+          raise Stripe::InvalidRequestError.new('Cannot specify proration date outside of current subscription period', nil, http_status: 400)
+        end
+
+        prorating = false
+        subscription_proration_date = nil
+        subscription_plan_id = params[:subscription_plan] || subscription[:plan][:id]
+        subscription_quantity = params[:subscription_quantity] || subscription[:quantity]
+        if subscription_plan_id != subscription[:plan][:id] || subscription_quantity != subscription[:quantity]
+          prorating = true
+          invoice_date = Time.now.to_i
+          subscription_plan = assert_existence :plan, subscription_plan_id, plans[subscription_plan_id.to_s]
+          preview_subscription = Data.mock_subscription
+          preview_subscription = resolve_subscription_changes(preview_subscription, [subscription_plan], customer, { trial_end: params[:subscription_trial_end] })
+          preview_subscription[:id] = subscription[:id]
+          preview_subscription[:quantity] = subscription_quantity
+          subscription_proration_date = params[:subscription_proration_date] || Time.now
+        else
+          preview_subscription = subscription
+          invoice_date = subscription[:current_period_end]
+        end
+
+        invoice_lines = []
+
+        if prorating
+          unused_amount = subscription[:plan][:amount] * subscription[:quantity] * (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+          invoice_lines << Data.mock_line_item(
+                                   id: new_id('ii'),
+                                   amount: -unused_amount,
+                                   description: 'Unused time',
+                                   plan: subscription[:plan],
+                                   period: {
+                                       start: subscription_proration_date.to_i,
+                                       end: subscription[:current_period_end]
+                                   },
+                                   quantity: subscription[:quantity],
+                                   proration: true
+          )
+
+          preview_plan = assert_existence :plan, params[:subscription_plan], plans[params[:subscription_plan]]
+          if preview_plan[:interval] == subscription[:plan][:interval] && preview_plan[:interval_count] == subscription[:plan][:interval_count] && params[:subscription_trial_end].nil?
+            remaining_amount = preview_plan[:amount] * subscription_quantity * (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+            invoice_lines << Data.mock_line_item(
+                                     id: new_id('ii'),
+                                     amount: remaining_amount,
+                                     description: 'Remaining time',
+                                     plan: preview_plan,
+                                     period: {
+                                         start: subscription_proration_date.to_i,
+                                         end: subscription[:current_period_end]
+                                     },
+                                     quantity: subscription_quantity,
+                                     proration: true
+            )
+          end
+        end
+
+        subscription_line = get_mock_subscription_line_item(preview_subscription)
+        invoice_lines << subscription_line
+
+        Data.mock_invoice(invoice_lines,
+          id: new_id('in'),
           customer: customer[:id],
-          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 )
+          discount: customer[:discount],
+          created: invoice_date,
+          starting_balance: customer[:account_balance],
+          subscription: preview_subscription[:id],
+          period_start: prorating ? invoice_date : preview_subscription[:current_period_start],
+          period_end: prorating ? invoice_date : preview_subscription[:current_period_end],
+          next_payment_attempt: preview_subscription[:current_period_end] + 3600 )
       end
 
       private
@@ -84,15 +153,25 @@ module StripeMock
           id: subscription[:id],
           type: "subscription",
           plan: subscription[:plan],
-          amount: subscription[:plan][:amount],
+          amount: subscription[:status] == 'trialing' ? 0 : subscription[:plan][:amount] * subscription[:quantity],
           discountable: true,
-          quantity: 1,
+          quantity: subscription[:quantity],
           period: {
             start: subscription[:current_period_end],
             end: get_ending_time(subscription[:current_period_start], subscription[:plan], 2)
           })
       end
 
+      ## charge the customer on the invoice, if one does not exist, create
+      #anonymous charge
+      def invoice_charge(invoice)
+        begin
+          new_charge(nil, nil, {customer: invoice[:customer]["id"], amount: invoice[:amount_due], currency: StripeMock.default_currency}, nil)
+        rescue Stripe::InvalidRequestError
+          new_charge(nil, nil, {source: generate_card_token, amount: invoice[:amount_due], currency: StripeMock.default_currency}, nil)
+        end
+      end
+
     end
   end
 end

data/lib/stripe_mock/request_handlers/orders.rb

@@ -15,16 +15,16 @@ module StripeMock
         order_items = []
 
         unless params[:currency].to_s.size == 3
-          raise Stripe::InvalidRequestError.new('You must supply a currency', nil, 400)
+          raise Stripe::InvalidRequestError.new('You must supply a currency', nil, http_status: 400)
         end
 
         if params[:items]
           unless params[:items].is_a? Array
-            raise Stripe::InvalidRequestError.new('You must supply a list of items', nil, 400)
+            raise Stripe::InvalidRequestError.new('You must supply a list of items', nil, http_status: 400)
           end
 
           unless params[:items].first.is_a? Hash
-            raise Stripe::InvalidRequestError.new('You must supply an item', nil, 400)
+            raise Stripe::InvalidRequestError.new('You must supply an item', nil, http_status: 400)
           end
         end
 
@@ -45,7 +45,7 @@ module StripeMock
           end
         end
 
-        if [:created, :paid, :canceled, :fulfilled, :returned].includes? params[:status]
+        if %w(created paid canceled fulfilled returned).include? params[:status]
           order[:status] = params[:status]
         end
         order
@@ -61,7 +61,7 @@ module StripeMock
         order = assert_existence :order, $1, orders[$1]
 
         if params[:source].blank? && params[:customer].blank?
-          raise Stripe::InvalidRequestError.new('You must supply a source or customer', nil, 400)
+          raise Stripe::InvalidRequestError.new('You must supply a source or customer', nil, http_status: 400)
         end
 
         charge_id = new_id('ch')

data/lib/stripe_mock/request_handlers/payouts.rb

@@ -0,0 +1,32 @@
+module StripeMock
+  module RequestHandlers
+    module Payouts
+
+      def Payouts.included(klass)
+        klass.add_handler 'post /v1/payouts',            :new_payout
+        klass.add_handler 'get /v1/payouts',             :list_payouts
+        klass.add_handler 'get /v1/payouts/(.*)',        :get_payout
+      end
+
+      def new_payout(route, method_url, params, headers)
+        id = new_id('po')
+
+        unless params[:amount].is_a?(Integer) || (params[:amount].is_a?(String) && /^\d+$/.match(params[:amount]))
+          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
+        end
+
+        payouts[id] = Data.mock_payout(params.merge :id => id)
+      end
+
+      def list_payouts(route, method_url, params, headers)
+        Data.mock_list_object(payouts.clone.values, params)
+      end
+
+      def get_payout(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :payout, $1, payouts[$1]
+        payouts[$1] ||= Data.mock_payout(:id => $1)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/plans.rb

@@ -11,6 +11,7 @@ module StripeMock
       end
 
       def new_plan(route, method_url, params, headers)
+        params[:id] ||= new_id('plan')
         validate_create_plan_params(params)
         plans[ params[:id] ] = Data.mock_plan(params)
       end

data/lib/stripe_mock/request_handlers/products.rb

@@ -0,0 +1,43 @@
+module StripeMock
+  module RequestHandlers
+    module Products
+      def self.included(base)
+        base.add_handler 'post /v1/products',        :create_product
+        base.add_handler 'get /v1/products/(.*)',    :retrieve_product
+        base.add_handler 'post /v1/products/(.*)',   :update_product
+        base.add_handler 'get /v1/products',         :list_products
+        base.add_handler 'delete /v1/products/(.*)', :destroy_product
+      end
+
+      def create_product(_route, _method_url, params, _headers)
+        params[:id] ||= new_id('prod')
+        products[params[:id]] = Data.mock_product(params)
+      end
+
+      def retrieve_product(route, method_url, _params, _headers)
+        id = method_url.match(route).captures.first
+        assert_existence :product, id, products[id]
+      end
+
+      def update_product(route, method_url, params, _headers)
+        id = method_url.match(route).captures.first
+        product = assert_existence :product, id, products[id]
+
+        product.merge!(params)
+      end
+
+      def list_products(_route, _method_url, params, _headers)
+        limit = params[:limit] || 10
+        Data.mock_list_object(products.values.take(limit), params)
+      end
+
+      def destroy_product(route, method_url, _params, _headers)
+        id = method_url.match(route).captures.first
+        assert_existence :product, id, products[id]
+
+        products.delete(id)
+        { id: id, object: 'product', deleted: true }
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/refunds.rb

@@ -10,12 +10,15 @@ module StripeMock
       end
 
       def new_refund(route, method_url, params, headers)
-        if params[:idempotency_key] && refunds.any?
-          original_refund = refunds.values.find { |c| c[:idempotency_key] == params[:idempotency_key]}
-          return refunds[original_refund[:id]] if original_refund
+        if headers && headers[:idempotency_key]
+          params[:idempotency_key] = headers[:idempotency_key]
+          if refunds.any?
+            original_refund = refunds.values.find { |c| c[:idempotency_key] == headers[:idempotency_key]}
+            return refunds[original_refund[:id]] if original_refund
+          end
         end
 
-        charge = get_charge(route, method_url, params, headers)
+        charge = assert_existence :charge, params[:charge], charges[params[:charge]]
         params[:amount] ||= charge[:amount]
         id = new_id('re')
         bal_trans_params = {
@@ -47,7 +50,7 @@ module StripeMock
         allowed = allowed_refund_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
 
         refunds[id] = Util.rmerge(refund, params)
@@ -72,9 +75,9 @@ module StripeMock
 
       def ensure_refund_required_params(params)
         if 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[:charge].nil?
           raise Stripe::InvalidRequestError.new('Must provide the identifier of the charge to refund.', nil)
         end

data/lib/stripe_mock/request_handlers/subscription_items.rb

@@ -0,0 +1,36 @@
+module StripeMock
+  module RequestHandlers
+    module SubscriptionItems
+
+      def SubscriptionItems.included(klass)
+        klass.add_handler 'get /v1/subscription_items', :retrieve_subscription_items
+        klass.add_handler 'post /v1/subscription_items/([^/]*)', :update_subscription_item
+        klass.add_handler 'post /v1/subscription_items', :create_subscription_items
+      end
+
+      def retrieve_subscription_items(route, method_url, params, headers)
+        route =~ method_url
+
+        require_param(:subscription) unless params[:subscription]
+
+        Data.mock_list_object(subscriptions_items, params)
+      end
+
+      def create_subscription_items(route, method_url, params, headers)
+        params[:id] ||= new_id('si')
+
+        require_param(:subscription) unless params[:subscription]
+        require_param(:plan) unless params[:plan]
+
+        subscriptions_items[params[:id]] = Data.mock_subscription_item(params.merge(plan: plans[params[:plan]]))
+      end
+
+      def update_subscription_item(route, method_url, params, headers)
+        route =~ method_url
+
+        subscription_item = assert_existence :subscription_item, $1, subscriptions_items[$1]
+        subscription_item.merge!(params.merge(plan: plans[params[:plan]]))
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -35,9 +35,7 @@ module StripeMock
       def create_customer_subscription(route, method_url, params, headers)
         route =~ method_url
 
-        plan_id = params[:plan].to_s
-        plan = assert_existence :plan, plan_id, plans[plan_id]
-
+        subscription_plans = get_subscription_plans_from_params(params)
         customer = assert_existence :customer, $1, customers[$1]
 
         if params[:source]
@@ -46,11 +44,12 @@ module StripeMock
           customer[:default_source] = new_card[:id]
         end
 
-        # Ensure customer has card to charge if plan has no trial and is not free
-        verify_card_present(customer, plan, params)
-
         subscription = Data.mock_subscription({ id: (params[:id] || new_id('su')) })
-        subscription.merge!(custom_subscription_params(plan, customer, params))
+        subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
+
+        # Ensure customer has card to charge if plan has no trial and is not free
+        # Note: needs updating for subscriptions with multiple plans
+        verify_card_present(customer, subscription_plans.first, subscription, params)
 
         if params[:coupon]
           coupon_id = params[:coupon]
@@ -61,9 +60,9 @@ module StripeMock
           coupon = coupons[coupon_id]
 
           if coupon
-            subscription[:discount] = Stripe::Util.convert_to_stripe_object({ coupon: coupon }, {})
+            add_coupon_to_object(subscription, coupon)
           else
-            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', 400)
+            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
 
@@ -74,25 +73,50 @@ module StripeMock
       end
 
       def create_subscription(route, method_url, params, headers)
+        if headers && headers[:idempotency_key]
+          if subscriptions.any?
+            original_subscription = subscriptions.values.find { |c| c[:idempotency_key] == headers[:idempotency_key]}
+            puts original_subscription
+            return subscriptions[original_subscription[:id]] if original_subscription
+          end
+        end
         route =~ method_url
 
-        plan_id = params[:plan].to_s
-        plan = assert_existence :plan, plan_id, plans[plan_id]
+        subscription_plans = get_subscription_plans_from_params(params)
 
-        customer_id = params[:customer].to_s
+        customer = params[:customer]
+        customer_id = customer.is_a?(Stripe::Customer) ? customer[:id] : customer.to_s
         customer = assert_existence :customer, customer_id, customers[customer_id]
 
+        if subscription_plans && customer
+          subscription_plans.each do |plan|
+            unless customer[:currency].to_s == plan[:currency].to_s
+              raise Stripe::InvalidRequestError.new("Customer's currency of #{customer[:currency]} does not match plan's currency of #{plan[:currency]}", 'currency', http_status: 400)
+            end
+          end
+        end
+
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
           add_card_to_object(:customer, new_card, customer)
           customer[:default_source] = new_card[:id]
         end
 
-        # Ensure customer has card to charge if plan has no trial and is not free
-        verify_card_present(customer, plan, params)
+        allowed_params = %w(customer application_fee_percent coupon items metadata plan quantity source tax_percent trial_end trial_period_days current_period_start created prorate billing_cycle_anchor billing days_until_due idempotency_key)
+        unknown_params = params.keys - allowed_params.map(&:to_sym)
+        if unknown_params.length > 0
+          raise Stripe::InvalidRequestError.new("Received unknown parameter: #{unknown_params.join}", unknown_params.first.to_s, http_status: 400)
+        end
 
         subscription = Data.mock_subscription({ id: (params[:id] || new_id('su')) })
-        subscription.merge!(custom_subscription_params(plan, customer, params))
+        subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
+        if headers[:idempotency_key]
+          subscription[:idempotency_key] = headers[:idempotency_key]
+        end
+
+        # Ensure customer has card to charge if plan has no trial and is not free
+        # Note: needs updating for subscriptions with multiple plans
+        verify_card_present(customer, subscription_plans.first, subscription, params)
 
         if params[:coupon]
           coupon_id = params[:coupon]
@@ -103,9 +127,9 @@ module StripeMock
           coupon = coupons[coupon_id]
 
           if coupon
-            subscription[:discount] = Stripe::Util.convert_to_stripe_object({ coupon: coupon }, {})
+            add_coupon_to_object(subscription, coupon)
           else
-            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', 400)
+            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
 
@@ -145,11 +169,12 @@ module StripeMock
           customer[:default_source] = new_card[:id]
         end
 
-        # expand the plan for addition to the customer object
-        plan_name =
-          params[:plan].is_a?(String) ? params[:plan] : subscription[:plan][:id]
+        subscription_plans = get_subscription_plans_from_params(params)
 
-        plan = plans[plan_name]
+        # subscription plans are not being updated but load them for the response
+        if subscription_plans.empty?
+          subscription_plans = subscription[:items][:data].map { |item| item[:plan] }
+        end
 
         if params[:coupon]
           coupon_id = params[:coupon]
@@ -159,17 +184,14 @@ module StripeMock
 
           coupon = coupons[coupon_id]
           if coupon
-            subscription[:discount] = Stripe::Util.convert_to_stripe_object({ coupon: coupon }, {})
+            add_coupon_to_object(subscription, coupon)
           elsif coupon_id == ""
-            subscription[:discount] = Stripe::Util.convert_to_stripe_object(nil, {})
+            subscription[:discount] = nil
           else
-            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', 400)
+            raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
-
-        assert_existence :plan, plan_name, plan
-        params[:plan] = plan if params[:plan]
-        verify_card_present(customer, plan)
+        verify_card_present(customer, subscription_plans.first, subscription)
 
         if subscription[:cancel_at_period_end]
           subscription[:cancel_at_period_end] = false
@@ -177,7 +199,8 @@ module StripeMock
         end
 
         params[:current_period_start] = subscription[:current_period_start]
-        subscription.merge!(custom_subscription_params(plan, customer, params))
+        params[:trial_end] = params[:trial_end] || subscription[:trial_end]
+        subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
 
         # delete the old subscription, replace with the new subscription
         customer[:subscriptions][:data].reject! { |sub| sub[:id] == subscription[:id] }
@@ -216,11 +239,49 @@ module StripeMock
 
       private
 
-      def verify_card_present(customer, plan, params={})
-        if customer[:default_source].nil? && customer[:trial_end].nil? && plan[:trial_period_days].nil? &&
-           plan[:amount] != 0 && plan[:trial_end].nil? && params[:trial_end].nil?
-          raise Stripe::InvalidRequestError.new('You must supply a valid card xoxo', nil, 400)
+      def get_subscription_plans_from_params(params)
+        plan_ids = if params[:plan]
+                     [params[:plan].to_s]
+                   elsif params[:items]
+                     items = params[:items]
+                     items = items.values if items.respond_to?(:values)
+                     items.map { |item| item[:plan].to_s if item[:plan] }
+                   else
+                     []
+                   end
+        plan_ids.each do |plan_id|
+          assert_existence :plan, plan_id, plans[plan_id]
         end
+        plan_ids.map { |plan_id| plans[plan_id] }
+      end
+
+      # Ensure customer has card to charge unless one of the following criterias is met:
+      # 1) is in trial
+      # 2) is free
+      # 3) has billing set to send invoice
+      def verify_card_present(customer, plan, subscription, params={})
+        return if customer[:default_source]
+        return if customer[:trial_end]
+        return if params[:trial_end]
+
+        plan_trial_period_days = plan[:trial_period_days] || 0
+        plan_has_trial = plan_trial_period_days != 0 || plan[:amount] == 0 || plan[:trial_end]
+        return if plan && plan_has_trial
+
+        return if subscription && subscription[:trial_end] && subscription[:trial_end] != 'now'
+
+        if subscription[:items]
+          trial = subscription[:items][:data].none? do |item|
+            plan = item[:plan]
+            (plan[:trial_period_days].nil? || plan[:trial_period_days] == 0) &&
+              (plan[:trial_end].nil? || plan[:trial_end] == 'now')
+          end
+          return if trial
+        end
+
+        return if params[:billing] == 'send_invoice'
+
+        raise Stripe::InvalidRequestError.new('You must supply a valid card xoxo', nil, http_status: 400)
       end
 
       def verify_active_status(subscription)
@@ -228,7 +289,7 @@ module StripeMock
 
         if status == 'canceled'
           message = "No such subscription: #{id}"
-          raise Stripe::InvalidRequestError.new(message, 'subscription', 404)
+          raise Stripe::InvalidRequestError.new(message, 'subscription', http_status: 404)
         end
       end
     end

data/lib/stripe_mock/request_handlers/tax_rates.rb

@@ -0,0 +1,36 @@
+module StripeMock
+  module RequestHandlers
+    module TaxRates
+      def TaxRates.included(klass)
+        klass.add_handler 'post /v1/tax_rates', :new_tax_rate
+        klass.add_handler 'post /v1/tax_rates/([^/]*)', :update_tax_rate
+        klass.add_handler 'get /v1/tax_rates/([^/]*)', :get_tax_rate
+        klass.add_handler 'get /v1/tax_rates', :list_tax_rates
+      end
+
+      def update_tax_rate(route, method_url, params, headers)
+        route =~ method_url
+        rate = assert_existence :tax_rate, $1, tax_rates[$1]
+        rate.merge!(params)
+        rate
+      end
+
+      def new_tax_rate(route, method_url, params, headers)
+        params[:id] ||= new_id('txr')
+        tax_rates[ params[:id] ] = Data.mock_tax_rate(params)
+        tax_rates[ params[:id] ]
+      end
+
+      def list_tax_rates(route, method_url, params, headers)
+        Data.mock_list_object(tax_rates.values, params)
+      end
+
+      def get_tax_rate(route, method_url, params, headers)
+        route =~ method_url
+        tax_rate = assert_existence :tax_rate, $1, tax_rates[$1]
+        tax_rate.clone
+      end
+    end
+  end
+end
+

data/lib/stripe_mock/request_handlers/tokens.rb

@@ -9,7 +9,7 @@ module StripeMock
 
       def create_token(route, method_url, params, headers)
         if params[:customer].nil? && params[:card].nil? && params[:bank_account].nil?
-          raise Stripe::InvalidRequestError.new('You must supply either a card, customer, or bank account to create a token.', nil, 400)
+          raise Stripe::InvalidRequestError.new('You must supply either a card, customer, or bank account to create a token.', nil, http_status: 400)
         end
 
         cus_id = params[:customer]
@@ -31,6 +31,12 @@ module StripeMock
           params[:card][:fingerprint] = StripeMock::Util.fingerprint(params[:card][:number])
           params[:card][:last4] = params[:card][:number][-4,4]
           customer_card = params[:card]
+        elsif params[:bank_account].is_a?(String)
+          customer = assert_existence :customer, cus_id, customers[cus_id]
+
+          # params[:bank_account] is an id; grab it from the db
+          bank_account = verify_bank_account(customer, params[:bank_account])
+          assert_existence :bank_account, params[:bank_account], bank_account
         elsif params[:bank_account]
           # params[:card] is a hash of cc info; "Sanitize" the card number
           bank_account = params[:bank_account]
@@ -40,12 +46,12 @@ module StripeMock
         end
 
         if bank_account
-          token_id = generate_bank_token(bank_account)
+          token_id = generate_bank_token(bank_account.dup)
           bank_account = @bank_tokens[token_id]
 
           Data.mock_bank_account_token(params.merge :id => token_id, :bank_account => bank_account)
         else
-          token_id = generate_card_token(customer_card)
+          token_id = generate_card_token(customer_card.dup)
           card = @card_tokens[token_id]
 
           Data.mock_card_token(params.merge :id => token_id, :card => card)