stripe-ruby-mock 2.5.8 → 3.1.0.rc3

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

@@ -17,26 +17,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))
@@ -73,10 +76,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 +89,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 +97,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(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 expand)
         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)
@@ -133,6 +128,15 @@ module StripeMock
           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
+        end
+
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
@@ -146,14 +150,16 @@ 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 = assert_existence :customer, $1, customers[stripe_account][$1]
         #customer[:subscriptions]
       end
 
       def update_subscription(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
 
         subscription_id = $2 ? $2 : $1
@@ -161,7 +167,7 @@ module StripeMock
         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 +197,28 @@ 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[: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 +227,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)
@@ -245,14 +263,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 +282,10 @@ 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 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 +304,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/validators/param_validators.rb

@@ -2,31 +2,145 @@ 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
+        product_id = params[:product]
+
+        @base_strategy.create_price_params.keys.each do |attr_name|
+          message = "Missing required param: #{attr_name}."
+          raise Stripe::InvalidRequestError.new(message, attr_name) if params[attr_name].nil?
+        end
+
+        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',