stripe-ruby-mock 2.3.1 → 2.5.8

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,32 +6,68 @@ 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
       end
 
       def add_subscription_to_customer(cus, sub)
-        id = new_id('ch')
-        charges[id] = Data.mock_charge(:id => id, :customer => cus[:id], :amount => sub[:plan][:amount])
+        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] ? 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
@@ -47,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)
@@ -62,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

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

@@ -28,14 +28,15 @@ 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
       end
 
       def get_card_or_bank_by_token(token)
-        @card_tokens[token] || @bank_tokens[token] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token}", 'tok', 404))
+        token_id = token['id'] || token
+         @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/recipients.rb

@@ -12,6 +12,18 @@ module StripeMock
         params[:id] ||= new_id('rp')
         cards = []
 
+        if params[:name].nil?
+          raise StripeMock::StripeMockError.new("Missing required parameter name for recipients.")
+        end
+
+        if params[:type].nil?
+          raise StripeMock::StripeMockError.new("Missing required parameter type for recipients.")
+        end
+
+        unless %w(individual corporation).include?(params[:type])
+          raise StripeMock::StripeMockError.new("Type must be either individual or corporation..")
+        end
+
         if params[:bank_account]
           params[:active_account] = get_bank_by_token(params.delete(:bank_account))
         end

data/lib/stripe_mock/request_handlers/refunds.rb

@@ -0,0 +1,91 @@
+module StripeMock
+  module RequestHandlers
+    module Refunds
+
+      def Refunds.included(klass)
+        klass.add_handler 'post /v1/refunds',               :new_refund
+        klass.add_handler 'get /v1/refunds',                :get_refunds
+        klass.add_handler 'get /v1/refunds/(.*)',           :get_refund
+        klass.add_handler 'post /v1/refunds/(.*)',          :update_refund
+      end
+
+      def new_refund(route, method_url, params, headers)
+        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 = assert_existence :charge, params[:charge], charges[params[:charge]]
+        params[:amount] ||= charge[:amount]
+        id = new_id('re')
+        bal_trans_params = {
+          amount: params[:amount] * -1,
+          source: id,
+          type: 'refund'
+        }
+        balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
+        refund = Data.mock_refund params.merge(
+          :balance_transaction => balance_transaction_id,
+          :id => id,
+          :charge => charge[:id],
+        )
+        add_refund_to_charge(refund, charge)
+        refunds[id] = refund
+
+        if params[:expand] == ['balance_transaction']
+          refunds[id][:balance_transaction] =
+            balance_transactions[balance_transaction_id]
+        end
+        refund
+      end
+
+      def update_refund(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        refund = assert_existence :refund, id, refunds[id]
+        allowed = allowed_refund_params(params)
+        disallowed = params.keys - allowed
+        if disallowed.count > 0
+          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', http_status: 400)
+        end
+
+        refunds[id] = Util.rmerge(refund, params)
+      end
+
+      def get_refunds(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = refunds.clone
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      def get_refund(route, method_url, params, headers)
+        route =~ method_url
+        refund_id = $1 || params[:refund]
+        assert_existence :refund, refund_id, refunds[refund_id]
+      end
+
+      private
+
+      def ensure_refund_required_params(params)
+        if non_integer_charge_amount?(params)
+          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', http_status: 400)
+        elsif params[:charge].nil?
+          raise Stripe::InvalidRequestError.new('Must provide the identifier of the charge to refund.', nil)
+        end
+      end
+
+      def allowed_refund_params(params)
+        [:metadata]
+      end
+    end
+  end
+end