stripe-ruby-mock 2.5.6 → 3.1.0.rc2

data/lib/stripe_mock/request_handlers/plans.rb

@@ -34,7 +34,7 @@ module StripeMock
 
       def list_plans(route, method_url, params, headers)
         limit = params[:limit] ? params[:limit] : 10
-        Data.mock_list_object(plans.values.first(limit), limit: limit)
+        Data.mock_list_object(plans.values.first(limit), params.merge!(limit: limit))
       end
 
     end

data/lib/stripe_mock/request_handlers/prices.rb

@@ -0,0 +1,44 @@
+module StripeMock
+  module RequestHandlers
+    module Prices
+
+      def Prices.included(klass)
+        klass.add_handler 'post /v1/prices',        :new_price
+        klass.add_handler 'post /v1/prices/(.*)',   :update_price
+        klass.add_handler 'get /v1/prices/(.*)',    :get_price
+        klass.add_handler 'get /v1/prices',         :list_prices
+      end
+
+      def new_price(route, method_url, params, headers)
+        params[:id] ||= new_id('price')
+        validate_create_price_params(params)
+        prices[ params[:id] ] = Data.mock_price(params)
+      end
+
+      def update_price(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :price, $1, prices[$1]
+        prices[$1].merge!(params)
+      end
+
+      def get_price(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :price, $1, prices[$1]
+      end
+
+      def list_prices(route, method_url, params, headers)
+        limit = params[:limit] ? params[:limit] : 10
+        price_data = prices.values
+        validate_list_prices_params(params)
+
+        if params.key?(:lookup_keys)
+          price_data.select! do |price|
+            params[:lookup_keys].include?(price[:lookup_key])
+          end
+        end
+
+        Data.mock_list_object(price_data.first(limit), params.merge!(limit: limit))
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/products.rb

@@ -0,0 +1,44 @@
+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')
+        validate_create_product_params(params)
+        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,9 +10,12 @@ 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 = assert_existence :charge, params[:charge], charges[params[:charge]]

data/lib/stripe_mock/request_handlers/setup_intents.rb

@@ -0,0 +1,93 @@
+module StripeMock
+  module RequestHandlers
+    module SetupIntents
+      ALLOWED_PARAMS = [
+        :confirm,
+        :customer,
+        :description,
+        :metadata,
+        :on_behalf_of,
+        :payment_method,
+        :payment_method_options,
+        :payment_method_types,
+        :return_url,
+        :usage
+      ]
+
+      def SetupIntents.included(klass)
+        klass.add_handler 'post /v1/setup_intents',               :new_setup_intent
+        klass.add_handler 'get /v1/setup_intents',                :get_setup_intents
+        klass.add_handler 'get /v1/setup_intents/(.*)',           :get_setup_intent
+        klass.add_handler 'post /v1/setup_intents/(.*)/confirm',  :confirm_setup_intent
+        klass.add_handler 'post /v1/setup_intents/(.*)/cancel',   :cancel_setup_intent
+        klass.add_handler 'post /v1/setup_intents/(.*)',          :update_setup_intent
+      end
+
+      def new_setup_intent(route, method_url, params, headers)
+        id = new_id('si')
+
+        setup_intents[id] = Data.mock_setup_intent(
+          params.merge(
+            id: id
+          )
+        )
+
+        setup_intents[id].clone
+      end
+
+      def update_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        setup_intent = assert_existence :setup_intent, id, setup_intents[id]
+        setup_intents[id] = Util.rmerge(setup_intent, params.select{ |k,v| ALLOWED_PARAMS.include?(k)})
+      end
+
+      def get_setup_intents(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = setup_intents.clone
+
+        if params[:customer]
+          clone.delete_if { |k,v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      def get_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent_id = $1 || params[:setup_intent]
+        setup_intent = assert_existence :setup_intent, setup_intent_id, setup_intents[setup_intent_id]
+
+        setup_intent = setup_intent.clone
+        setup_intent
+      end
+
+      def capture_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent = assert_existence :setup_intent, $1, setup_intents[$1]
+
+        setup_intent[:status] = 'succeeded'
+        setup_intent
+      end
+
+      def confirm_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent = assert_existence :setup_intent, $1, setup_intents[$1]
+
+        setup_intent[:status] = 'succeeded'
+        setup_intent
+      end
+
+      def cancel_setup_intent(route, method_url, params, headers)
+        route =~ method_url
+        setup_intent = assert_existence :setup_intent, $1, setup_intents[$1]
+
+        setup_intent[:status] = 'canceled'
+        setup_intent
+      end
+    end
+  end
+end

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/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

@@ -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))
@@ -60,7 +63,7 @@ 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', http_status: 400)
           end
@@ -73,21 +76,20 @@ 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]}
+            return subscriptions[original_subscription[:id]] if original_subscription
+          end
+        end
         route =~ method_url
 
         subscription_plans = get_subscription_plans_from_params(params)
 
         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))
@@ -95,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)
+        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)
@@ -103,6 +105,9 @@ module StripeMock
 
         subscription = Data.mock_subscription({ id: (params[:id] || new_id('su')) })
         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
@@ -117,12 +122,21 @@ 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', 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
+        end
+
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
@@ -136,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
@@ -151,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))
@@ -174,23 +190,35 @@ 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', 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
@@ -199,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)
@@ -234,36 +263,48 @@ 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:
+      # 1) is in trial
+      # 2) is free
+      # 3) has billing set to send invoice
       def verify_card_present(customer, plan, subscription, params={})
-        if customer[:default_source].nil? && customer[:trial_end].nil? &&
-          (plan.nil? ||
-            ((plan[:trial_period_days] || 0) == 0 &&
-              plan[:amount] != 0 &&
-              plan[:trial_end].nil?)) &&
-          params[:trial_end].nil? &&
-          (subscription.nil? || subscription[:trial_end].nil? || 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
+        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]
+        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
-
-          raise Stripe::InvalidRequestError.new('You must supply a valid card xoxo', nil, http_status: 400)
+          return if trial
         end
+
+        return if params[:billing] == 'send_invoice'
+
+        raise Stripe::InvalidRequestError.new('This customer has no attached payment source', nil, http_status: 400)
       end
 
       def verify_active_status(subscription)