stripe-ruby-mock 2.5.8 → 4.0.0

data/lib/stripe_mock/request_handlers/sources.rb

@@ -12,30 +12,35 @@ module StripeMock
       end
 
       def create_source(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        add_source_to(:customer, $1, params, customers)
+        add_source_to(:customer, $1, params, customers[stripe_account])
       end
 
       def retrieve_sources(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        retrieve_object_cards(:customer, $1, customers)
+        retrieve_object_cards(:customer, $1, customers[stripe_account])
       end
 
       def retrieve_source(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
 
         assert_existence :card, $2, get_card(customer, $2)
       end
 
       def delete_source(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        delete_card_from(:customer, $1, $2, customers)
+        delete_card_from(:customer, $1, $2, customers[stripe_account])
       end
 
       def update_source(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
 
         card = assert_existence :card, $2, get_card(customer, $2)
         card.merge!(params)
@@ -43,8 +48,9 @@ module StripeMock
       end
 
       def verify_source(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
 
         bank_account = assert_existence :bank_account, $2, verify_bank_account(customer, $2)
         bank_account

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -5,8 +5,9 @@ module StripeMock
       def Subscriptions.included(klass)
         klass.add_handler 'get /v1/subscriptions', :retrieve_subscriptions
         klass.add_handler 'post /v1/subscriptions', :create_subscription
-        klass.add_handler 'get /v1/subscriptions/(.*)', :retrieve_subscription
+        klass.add_handler 'get /v1/subscriptions/((?!search).*)', :retrieve_subscription
         klass.add_handler 'post /v1/subscriptions/(.*)', :update_subscription
+        klass.add_handler 'get /v1/subscriptions/search', :search_subscriptions
         klass.add_handler 'delete /v1/subscriptions/(.*)', :cancel_subscription
 
         klass.add_handler 'post /v1/customers/(.*)/subscription(?:s)?', :create_customer_subscription
@@ -17,26 +18,29 @@ module StripeMock
       end
 
       def retrieve_customer_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
         subscription = get_customer_subscription(customer, $2)
 
         assert_existence :subscription, $2, subscription
       end
 
       def retrieve_customer_subscriptions(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
         customer[:subscriptions]
       end
 
       def create_customer_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
         subscription_plans = get_subscription_plans_from_params(params)
-        customer = assert_existence :customer, $1, customers[$1]
+        customer = assert_existence :customer, $1, customers[stripe_account][$1]
 
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
@@ -66,6 +70,16 @@ module StripeMock
           end
         end
 
+        if params[:promotion_code]
+          promotion_code_id = params[:promotion_code]
+
+          promotion_code = promotion_codes[promotion_code_id]
+
+          unless promotion_code
+            raise Stripe::InvalidRequestError.new("No such promotion code: #{promotion_code_id}", 'promotion_code', http_status: 400)
+          end
+        end
+
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
@@ -73,10 +87,10 @@ module StripeMock
       end
 
       def create_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         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
@@ -86,15 +100,7 @@ module StripeMock
 
         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
+        customer = assert_existence :customer, customer_id, customers[stripe_account][customer_id]
 
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
@@ -102,7 +108,7 @@ module StripeMock
           customer[:default_source] = new_card[:id]
         end
 
-        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)
+        allowed_params = %w(id 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 enable_incomplete_payments cancel_at_period_end default_tax_rates payment_behavior pending_invoice_item_interval default_payment_method collection_method off_session trial_from_plan proration_behavior backdate_start_date transfer_data expand automatic_tax payment_settings trial_settings promotion_code)
         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)
@@ -118,6 +124,10 @@ module StripeMock
         # Note: needs updating for subscriptions with multiple plans
         verify_card_present(customer, subscription_plans.first, subscription, params)
 
+        if params[:coupon] && params[:promotion_code]
+          raise Stripe::InvalidRequestError.new("You may only specify one of these parameters: coupon, promotion_code", "coupon", http_status: 400)
+        end
+
         if params[:coupon]
           coupon_id = params[:coupon]
 
@@ -133,6 +143,50 @@ module StripeMock
           end
         end
 
+        if params[:promotion_code]
+          promotion_code_id = params[:promotion_code]
+
+          promotion_code = promotion_codes[promotion_code_id]
+
+          unless promotion_code
+            raise Stripe::InvalidRequestError.new("No such promotion code: #{promotion_code_id}", 'promotion_code', http_status: 400)
+          end
+        end
+
+        if params[:trial_period_days]
+          subscription[:status] = 'trialing'
+        end
+
+        if params[:payment_behavior] == 'default_incomplete'
+          subscription[:status] = 'incomplete'
+        end
+
+        if params[:cancel_at_period_end]
+          subscription[:cancel_at_period_end] = true
+          subscription[:canceled_at] = Time.now.utc.to_i
+        end
+
+        if params[:transfer_data] && !params[:transfer_data].empty?
+          throw Stripe::InvalidRequestError.new(missing_param_message("transfer_data[destination]")) unless params[:transfer_data][:destination]
+          subscription[:transfer_data] = params[:transfer_data].dup
+          subscription[:transfer_data][:amount_percent] ||= 100
+        end
+
+        if (s = params[:expand]&.find { |s| s.start_with? 'latest_invoice' })
+          payment_intent = nil
+          unless subscription[:status] == 'trialing'
+            intent_status = subscription[:status] == 'incomplete' ? 'requires_payment_method' : 'succeeded'
+            intent = Data.mock_payment_intent({
+              status: intent_status,
+              amount: subscription[:plan][:amount],
+              currency: subscription[:plan][:currency]
+            })
+            payment_intent = s.include?('latest_invoice.payment_intent') ? intent : intent.id
+          end
+          invoice = Data.mock_invoice([], { payment_intent: payment_intent })
+          subscription[:latest_invoice] = invoice
+        end
+
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
@@ -146,22 +200,43 @@ module StripeMock
       end
 
       def retrieve_subscriptions(route, method_url, params, headers)
+        # stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
-        Data.mock_list_object(subscriptions.values, params)
-        #customer = assert_existence :customer, $1, customers[$1]
-        #customer[:subscriptions]
+        subs = subscriptions.values
+
+        case params[:status]
+        when nil
+          subs = subs.filter {|subscription| subscription[:status] != "canceled"}
+        when "all"
+          # Include all subscriptions
+        else
+          subs = subs.filter {|subscription| subscription[:status] == params[:status]}
+        end
+        if params[:current_period_end]
+          subs = filter_by_timestamp(subs, field: :current_period_end, value: params[:current_period_end])
+        end
+        if params[:current_period_start]
+          subs = filter_by_timestamp(subs, field: :current_period_start, value: params[:current_period_start])
+        end
+
+        Data.mock_list_object(subs, params)
       end
 
       def update_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
+        if params[:billing_cycle_anchor] == 'now'
+          params[:billing_cycle_anchor] = Time.now.utc.to_i
+        end
+
         subscription_id = $2 ? $2 : $1
         subscription = assert_existence :subscription, subscription_id, subscriptions[subscription_id]
         verify_active_status(subscription)
 
         customer_id = subscription[:customer]
-        customer = assert_existence :customer, customer_id, customers[customer_id]
+        customer = assert_existence :customer, customer_id, customers[stripe_account][customer_id]
 
         if params[:source]
           new_card = get_card_by_token(params.delete(:source))
@@ -191,17 +266,48 @@ module StripeMock
             raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
-        verify_card_present(customer, subscription_plans.first, subscription)
 
-        if subscription[:cancel_at_period_end]
+        if params[:promotion_code]
+          promotion_code_id = params[:promotion_code]
+
+          promotion_code = promotion_codes[promotion_code_id]
+
+          if promotion_code
+            # You can't apply a promotion code with amount restrictions on the Customer object or on a subscription
+            # update API call
+            if promotion_code[:restrictions][:minimum_amount]
+              raise Stripe::InvalidRequestError.new(
+                "This promotion code cannot be redeemed on a subcription update because it uses the `minimum_amount` restriction.",
+                "promotion_code",
+                http_status: 400
+              )
+            end
+          else
+            raise Stripe::InvalidRequestError.new("No such promotion code: #{promotion_code_id}", 'promotion_code', http_status: 400)
+          end
+        end
+
+        if params[:trial_period_days]
+          subscription[:status] = 'trialing'
+        end
+
+        if params[:cancel_at_period_end]
+          subscription[:cancel_at_period_end] = true
+          subscription[:canceled_at] = Time.now.utc.to_i
+        elsif params.has_key?(:cancel_at_period_end)
           subscription[:cancel_at_period_end] = false
           subscription[:canceled_at] = nil
         end
 
         params[:current_period_start] = subscription[:current_period_start]
         params[:trial_end] = params[:trial_end] || subscription[:trial_end]
+
+        plan_amount_was = subscription.dig(:plan, :amount)
+
         subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
 
+        verify_card_present(customer, subscription_plans.first, subscription, params) if plan_amount_was == 0 && subscription.dig(:plan, :amount) && subscription.dig(:plan, :amount) > 0
+
         # delete the old subscription, replace with the new subscription
         customer[:subscriptions][:data].reject! { |sub| sub[:id] == subscription[:id] }
         customer[:subscriptions][:data] << subscription
@@ -210,13 +316,14 @@ module StripeMock
       end
 
       def cancel_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
         subscription_id = $2 ? $2 : $1
         subscription = assert_existence :subscription, subscription_id, subscriptions[subscription_id]
 
         customer_id = subscription[:customer]
-        customer = assert_existence :customer, customer_id, customers[customer_id]
+        customer = assert_existence :customer, customer_id, customers[stripe_account][customer_id]
 
         cancel_params = { canceled_at: Time.now.utc.to_i }
         cancelled_at_period_end = (params[:at_period_end] == true)
@@ -237,6 +344,14 @@ module StripeMock
         subscription
       end
 
+      SEARCH_FIELDS = ["status"].freeze
+      def search_subscriptions(route, method_url, params, headers)
+        require_param(:query) unless params[:query]
+
+        results = search_results(subscriptions.values, params[:query], fields: SEARCH_FIELDS, resource_name: "subscriptions")
+        Data.mock_list_object(results, params)
+      end
+
       private
 
       def get_subscription_plans_from_params(params)
@@ -245,14 +360,17 @@ module StripeMock
                    elsif params[:items]
                      items = params[:items]
                      items = items.values if items.respond_to?(:values)
-                     items.map { |item| item[:plan].to_s if item[:plan] }
+                     items.map { |item| item[:plan] ? item[:plan] : item[:price] }
                    else
                      []
                    end
+        plan_ids.compact!
         plan_ids.each do |plan_id|
           assert_existence :plan, plan_id, plans[plan_id]
+        rescue Stripe::InvalidRequestError
+          assert_existence :price, plan_id, prices[plan_id]
         end
-        plan_ids.map { |plan_id| plans[plan_id] }
+        plan_ids.map { |plan_id| plans[plan_id] || prices[plan_id]}
       end
 
       # Ensure customer has card to charge unless one of the following criterias is met:
@@ -261,8 +379,11 @@ module StripeMock
       # 3) has billing set to send invoice
       def verify_card_present(customer, plan, subscription, params={})
         return if customer[:default_source]
+        return if customer[:invoice_settings][:default_payment_method]
         return if customer[:trial_end]
         return if params[:trial_end]
+        return if params[:payment_behavior] == 'default_incomplete'
+        return if subscription[:default_payment_method]
 
         plan_trial_period_days = plan[:trial_period_days] || 0
         plan_has_trial = plan_trial_period_days != 0 || plan[:amount] == 0 || plan[:trial_end]
@@ -281,7 +402,7 @@ module StripeMock
 
         return if params[:billing] == 'send_invoice'
 
-        raise Stripe::InvalidRequestError.new('You must supply a valid card xoxo', nil, http_status: 400)
+        raise Stripe::InvalidRequestError.new('This customer has no attached payment source', nil, http_status: 400)
       end
 
       def verify_active_status(subscription)

data/lib/stripe_mock/request_handlers/tokens.rb

@@ -8,6 +8,8 @@ module StripeMock
       end
 
       def create_token(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
+
         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, http_status: 400)
         end
@@ -15,13 +17,13 @@ module StripeMock
         cus_id = params[:customer]
 
         if cus_id && params[:source]
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id]
 
           # params[:card] is an id; grab it from the db
           customer_card = get_card(customer, params[:source])
           assert_existence :card, params[:source], customer_card
         elsif params[:card].is_a?(String)
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id]
 
           # params[:card] is an id; grab it from the db
           customer_card = get_card(customer, params[:card])
@@ -32,7 +34,7 @@ module StripeMock
           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]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id]
 
           # params[:bank_account] is an id; grab it from the db
           bank_account = verify_bank_account(customer, params[:bank_account])
@@ -41,7 +43,7 @@ module StripeMock
           # params[:card] is a hash of cc info; "Sanitize" the card number
           bank_account = params[:bank_account]
         else
-          customer = assert_existence :customer, cus_id, customers[cus_id]
+          customer = assert_existence :customer, cus_id, customers[stripe_account][cus_id] || customers[Stripe.api_key][cus_id]
           customer_card = get_card(customer, customer[:default_source])
         end
 

data/lib/stripe_mock/request_handlers/transfers.rb

@@ -45,7 +45,18 @@ module StripeMock
           raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
         end
 
-        transfers[id] = Data.mock_transfer(params.merge :id => id)
+        bal_trans_params = { amount: params[:amount].to_i, source: id }
+
+        balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
+
+        transfers[id] = Data.mock_transfer(params.merge(id: id, balance_transaction: balance_transaction_id))
+
+        transfer = transfers[id].clone
+        if params[:expand] == ['balance_transaction']
+          transfer[:balance_transaction] = balance_transactions[balance_transaction_id]
+        end
+
+        transfer
       end
 
       def get_transfer(route, method_url, params, headers)

data/lib/stripe_mock/request_handlers/validators/param_validators.rb

@@ -2,31 +2,146 @@ module StripeMock
   module RequestHandlers
     module ParamValidators
 
-      def validate_create_plan_params(params)
+      def already_exists_message(obj_class)
+        "#{obj_class.to_s.split("::").last} already exists."
+      end
+
+      def not_found_message(obj_class, obj_id)
+        "No such #{obj_class.to_s.split("::").last.downcase}: #{obj_id}"
+      end
+
+      def missing_param_message(attr_name)
+        "Missing required param: #{attr_name}."
+      end
+
+      def invalid_integer_message(my_val)
+        "Invalid integer: #{my_val}"
+      end
+
+      #
+      # ProductValidator
+      #
+
+
+      def validate_create_product_params(params)
         params[:id] = params[:id].to_s
+        @base_strategy.create_product_params.keys.reject{ |k,_| k == :id }.each do |k|
+          raise Stripe::InvalidRequestError.new(missing_param_message(k), k) if params[k].nil?
+        end
+
+        if products[ params[:id] ]
+          raise Stripe::InvalidRequestError.new(already_exists_message(Stripe::Product), :id)
+        end
+      end
+
+      #
+      # PlanValidator
+      #
+
+      def missing_plan_amount_message
+        "Plans require an `amount` parameter to be set."
+      end
+
+      SUPPORTED_PLAN_INTERVALS = ["month", "year", "week", "day"]
+
+      def invalid_plan_interval_message
+        "Invalid interval: must be one of day, month, week, or year"
+      end
+
+      SUPPORTED_CURRENCIES = [
+        "usd", "aed", "afn", "all", "amd", "ang", "aoa", "ars", "aud", "awg", "azn", "bam", "bbd", "bdt", "bgn",
+        "bif", "bmd", "bnd", "bob", "brl", "bsd", "bwp", "bzd", "cad", "cdf", "chf", "clp", "cny", "cop", "crc",
+        "cve", "czk", "djf", "dkk", "dop", "dzd", "egp", "etb", "eur", "fjd", "fkp", "gbp", "gel", "gip", "gmd",
+        "gnf", "gtq", "gyd", "hkd", "hnl", "hrk", "htg", "huf", "idr", "ils", "inr", "isk", "jmd", "jpy", "kes",
+        "kgs", "khr", "kmf", "krw", "kyd", "kzt", "lak", "lbp", "lkr", "lrd", "lsl", "mad", "mdl", "mga", "mkd",
+        "mmk", "mnt", "mop", "mro", "mur", "mvr", "mwk", "mxn", "myr", "mzn", "nad", "ngn", "nio", "nok", "npr",
+        "nzd", "pab", "pen", "pgk", "php", "pkr", "pln", "pyg", "qar", "ron", "rsd", "rub", "rwf", "sar", "sbd",
+        "scr", "sek", "sgd", "shp", "sll", "sos", "srd", "std", "szl", "thb", "tjs", "top", "try", "ttd", "twd",
+        "tzs", "uah", "ugx", "uyu", "uzs", "vnd", "vuv", "wst", "xaf", "xcd", "xof", "xpf", "yer", "zar", "zmw",
+        "eek", "lvl", "svc", "vef", "ltl"
+      ]
+
+      def invalid_currency_message(my_val)
+        "Invalid currency: #{my_val.downcase}. Stripe currently supports these currencies: #{SUPPORTED_CURRENCIES.join(", ")}"
+      end
 
-        @base_strategy.create_plan_params.keys.each do |name|
+      def validate_create_plan_params(params)
+        plan_id = params[:id].to_s
+        product_id = params[:product]
+
+        @base_strategy.create_plan_params.keys.each do |attr_name|
           message =
-            if name == :amount
-              "Plans require an `#{name}` parameter to be set."
+            if attr_name == :amount
+              "Plans require an `#{attr_name}` parameter to be set."
             else
-              "Missing required param: #{name}."
+              "Missing required param: #{attr_name}."
             end
-          raise Stripe::InvalidRequestError.new(message, name) if params[name].nil?
+          raise Stripe::InvalidRequestError.new(message, attr_name) if params[attr_name].nil?
+        end
+
+        if plans[plan_id]
+          message = already_exists_message(Stripe::Plan)
+          raise Stripe::InvalidRequestError.new(message, :id)
+        end
+
+        unless products[product_id]
+          message = not_found_message(Stripe::Product, product_id)
+          raise Stripe::InvalidRequestError.new(message, :product)
         end
 
-        if plans[ params[:id] ]
-          raise Stripe::InvalidRequestError.new("Plan already exists.", :id)
+        unless SUPPORTED_PLAN_INTERVALS.include?(params[:interval])
+          message = invalid_plan_interval_message
+          raise Stripe::InvalidRequestError.new(message, :interval)
+        end
+
+        unless SUPPORTED_CURRENCIES.include?(params[:currency])
+          message = invalid_currency_message(params[:currency])
+          raise Stripe::InvalidRequestError.new(message, :currency)
         end
 
         unless params[:amount].integer?
-          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", :amount)
+          message = invalid_integer_message(params[:amount])
+          raise Stripe::InvalidRequestError.new(message, :amount)
+        end
+
+      end
+
+      def validate_create_price_params(params)
+        price_id = params[:id].to_s
+
+        require_param(:currency) unless params[:currency]
+        unless params[:product] || params[:product_data]
+          raise Stripe::InvalidRequestError("Requires product or product_data")
+        end
+
+        product_id = params[:product] || create_product(nil, nil, params[:product_data], nil).id
+
+        if prices[price_id]
+          message = already_exists_message(Stripe::Price)
+          raise Stripe::InvalidRequestError.new(message, :id)
+        end
+
+        unless products[product_id]
+          message = not_found_message(Stripe::Product, product_id)
+          raise Stripe::InvalidRequestError.new(message, :product)
+        end
+
+        unless SUPPORTED_CURRENCIES.include?(params[:currency])
+          message = invalid_currency_message(params[:currency])
+          raise Stripe::InvalidRequestError.new(message, :currency)
+        end
+      end
+
+      def validate_list_prices_params(params)
+        if params[:lookup_keys] && !params[:lookup_keys].is_a?(Array)
+          raise Stripe::InvalidRequestError.new('Invalid array', :lookup_keys)
         end
       end
 
       def require_param(param_name)
         raise Stripe::InvalidRequestError.new("Missing required param: #{param_name}.", param_name.to_s, http_status: 400)
       end
+
     end
   end
 end

data/lib/stripe_mock/server.rb

@@ -16,9 +16,9 @@ module StripeMock
       self.clear_data
     end
 
-    def mock_request(*args)
+    def mock_request(*args, **kwargs)
       begin
-        @instance.mock_request(*args)
+        @instance.mock_request(*args, **kwargs)
       rescue Stripe::InvalidRequestError => e
         {
           :error_raised => 'invalid_request',