stripe-ruby-mock 2.5.8 → 3.1.0.rc3

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

@@ -36,7 +36,7 @@ module StripeMock
 
       def get_card_or_bank_by_token(token)
         token_id = token['id'] || token
-         @card_tokens[token_id] || @bank_tokens[token_id] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token_id}", 'tok', http_status: 404))
+        @card_tokens[token_id] || @bank_tokens[token_id] || raise(Stripe::InvalidRequestError.new("Invalid token id: #{token_id}", 'tok', http_status: 404))
       end
 
     end

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -56,13 +56,14 @@ module StripeMock
         invoices[$1].merge!(:paid => true, :attempted => true, :charge => charge[:id])
       end
 
-      def upcoming_invoice(route, method_url, params, headers)
+      def upcoming_invoice(route, method_url, params, headers = {})
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
         route =~ method_url
-        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, http_status: 400) if params[:customer].nil?
+        raise Stripe::InvalidRequestError.new('Missing required param: customer if subscription is not provided', nil, http_status: 400) if params[:customer].nil? && params[:subscription].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]]
+        customer = customers[stripe_account][params[:customer]]
         assert_existence :customer, params[:customer], customer
 
         raise Stripe::InvalidRequestError.new("No upcoming invoices for customer: #{customer[:id]}", nil, http_status: 404) if customer[:subscriptions][:data].length == 0
@@ -99,7 +100,12 @@ module StripeMock
         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])
+          unused_amount = (
+            subscription[:plan][:amount].to_f *
+              subscription[:quantity] *
+              (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+            ).ceil
+
           invoice_lines << Data.mock_line_item(
                                    id: new_id('ii'),
                                    amount: -unused_amount,

data/lib/stripe_mock/request_handlers/payment_intents.rb

@@ -0,0 +1,182 @@
+module StripeMock
+  module RequestHandlers
+    module PaymentIntents
+      ALLOWED_PARAMS = [:description, :metadata, :receipt_email, :shipping, :destination, :payment_method, :payment_method_types, :setup_future_usage, :transfer_data, :amount, :currency]
+
+      def PaymentIntents.included(klass)
+        klass.add_handler 'post /v1/payment_intents',               :new_payment_intent
+        klass.add_handler 'get /v1/payment_intents',                :get_payment_intents
+        klass.add_handler 'get /v1/payment_intents/(.*)',           :get_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)/confirm',  :confirm_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)/capture',  :capture_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)/cancel',   :cancel_payment_intent
+        klass.add_handler 'post /v1/payment_intents/(.*)',          :update_payment_intent
+      end
+
+      def new_payment_intent(route, method_url, params, headers)
+        id = new_id('pi')
+
+        ensure_payment_intent_required_params(params)
+        status = case params[:amount]
+        when 3184 then 'requires_action'
+        when 3178 then 'requires_payment_method'
+        when 3055 then 'requires_capture'
+        else
+          'succeeded'
+        end
+        last_payment_error = params[:amount] == 3178 ? last_payment_error_generator(code: 'card_declined', decline_code: 'insufficient_funds', message: 'Not enough funds.') : nil
+        payment_intents[id] = Data.mock_payment_intent(
+          params.merge(
+            id: id,
+            status: status,
+            last_payment_error: last_payment_error
+          )
+        )
+
+        if params[:confirm] && status == 'succeeded'
+          payment_intents[id] = succeeded_payment_intent(payment_intents[id])
+        end
+
+        payment_intents[id].clone
+      end
+
+      def update_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        payment_intent = assert_existence :payment_intent, id, payment_intents[id]
+        payment_intents[id] = Util.rmerge(payment_intent, params.select{ |k,v| ALLOWED_PARAMS.include?(k)})
+      end
+
+      def get_payment_intents(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = payment_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_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent_id = $1 || params[:payment_intent]
+        payment_intent = assert_existence :payment_intent, payment_intent_id, payment_intents[payment_intent_id]
+
+        payment_intent = payment_intent.clone
+        payment_intent
+      end
+
+      def capture_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent = assert_existence :payment_intent, $1, payment_intents[$1]
+
+        succeeded_payment_intent(payment_intent)
+      end
+
+      def confirm_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent = assert_existence :payment_intent, $1, payment_intents[$1]
+
+        succeeded_payment_intent(payment_intent)
+      end
+
+      def cancel_payment_intent(route, method_url, params, headers)
+        route =~ method_url
+        payment_intent = assert_existence :payment_intent, $1, payment_intents[$1]
+
+        payment_intent[:status] = 'canceled'
+        payment_intent
+      end
+
+      private
+
+      def ensure_payment_intent_required_params(params)
+        if params[:amount].nil?
+          require_param(:amount)
+        elsif params[:currency].nil?
+          require_param(:currency)
+        elsif 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)
+        end
+      end
+
+      def non_integer_charge_amount?(params)
+        params[:amount] && !params[:amount].is_a?(Integer)
+      end
+
+      def non_positive_charge_amount?(params)
+        params[:amount] && params[:amount] < 1
+      end
+
+      def last_payment_error_generator(code: nil, message: nil, decline_code: nil)
+        {
+          code: code,
+          doc_url: "https://stripe.com/docs/error-codes/payment-intent-authentication-failure",
+          message: message,
+          decline_code: decline_code,
+          payment_method: {
+            id: "pm_1EwXFA2eZvKYlo2C0tlY091l",
+            object: "payment_method",
+            billing_details: {
+              address: {
+                city: nil,
+                country: nil,
+                line1: nil,
+                line2: nil,
+                postal_code: nil,
+                state: nil
+              },
+              email: nil,
+              name: "seller_08072019090000",
+              phone: nil
+            },
+            card: {
+              brand: "visa",
+              checks: {
+                address_line1_check: nil,
+                address_postal_code_check: nil,
+                cvc_check: "unchecked"
+              },
+              country: "US",
+              exp_month: 12,
+              exp_year: 2021,
+              fingerprint: "LQBhEmJnItuj3mxf",
+              funding: "credit",
+              generated_from: nil,
+              last4: "1629",
+              three_d_secure_usage: {
+                supported: true
+              },
+              wallet: nil
+            },
+            created: 1563208900,
+            customer: nil,
+            livemode: false,
+            metadata: {},
+            type: "card"
+          },
+          type: "invalid_request_error"
+        }
+      end
+
+      def succeeded_payment_intent(payment_intent)
+        payment_intent[:status] = 'succeeded'
+        btxn = new_balance_transaction('txn', { source: payment_intent[:id] })
+
+        payment_intent[:charges][:data] << Data.mock_charge(
+          balance_transaction: btxn,
+          amount: payment_intent[:amount],
+          currency: payment_intent[:currency]
+        )
+
+        payment_intent
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/payment_methods.rb

@@ -0,0 +1,120 @@
+module StripeMock
+  module RequestHandlers
+    module PaymentMethods
+      ALLOWED_PARAMS = [:customer, :type]
+
+      def PaymentMethods.included(klass)
+        klass.add_handler 'post /v1/payment_methods',             :new_payment_method
+        klass.add_handler 'get /v1/payment_methods/(.*)',         :get_payment_method
+        klass.add_handler 'get /v1/payment_methods',              :get_payment_methods
+        klass.add_handler 'post /v1/payment_methods/(.*)/attach', :attach_payment_method
+        klass.add_handler 'post /v1/payment_methods/(.*)/detach', :detach_payment_method
+        klass.add_handler 'post /v1/payment_methods/(.*)',        :update_payment_method
+      end
+
+      # post /v1/payment_methods
+      def new_payment_method(route, method_url, params, headers)
+        id = new_id('pm')
+
+        ensure_payment_method_required_params(params)
+
+        payment_methods[id] = Data.mock_payment_method(
+          params.merge(
+            id: id
+          )
+        )
+
+        payment_methods[id].clone
+      end
+
+      #
+      # params: {:type=>"card", :customer=>"test_cus_3"}
+      #
+      # get /v1/payment_methods/:id
+      def get_payment_method(route, method_url, params, headers)
+        id = method_url.match(route)[1] || params[:payment_method]
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+
+        payment_method.clone
+      end
+
+      # get /v1/payment_methods
+      def get_payment_methods(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = payment_methods.clone
+
+        if params[:customer]
+          clone.delete_if { |_k, v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      # post /v1/payment_methods/:id/attach
+      def attach_payment_method(route, method_url, params, headers)
+        stripe_account = headers && headers[:stripe_account] || Stripe.api_key
+        allowed_params = [:customer]
+
+        id = method_url.match(route)[1]
+
+        assert_existence :customer, params[:customer], customers[stripe_account][params[:customer]]
+
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+        payment_methods[id] = Util.rmerge(payment_method, params.select { |k, _v| allowed_params.include?(k) })
+        payment_methods[id].clone
+      end
+
+      # post /v1/payment_methods/:id/detach
+      def detach_payment_method(route, method_url, params, headers)
+        id = method_url.match(route)[1]
+
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+        payment_method[:customer] = nil
+
+        payment_method.clone
+      end
+
+      # post /v1/payment_methods/:id
+      def update_payment_method(route, method_url, params, headers)
+        allowed_params = [:billing_details, :card, :ideal, :sepa_debit, :metadata]
+
+        id = method_url.match(route)[1]
+
+        payment_method = assert_existence :payment_method, id, payment_methods[id]
+
+        if payment_method[:customer].nil?
+          raise Stripe::InvalidRequestError.new(
+            'You must save this PaymentMethod to a customer before you can update it.',
+            nil,
+            http_status: 400
+          )
+        end
+
+        payment_methods[id] =
+          Util.rmerge(payment_method, params.select { |k, _v| allowed_params.include?(k)} )
+
+        payment_methods[id].clone
+      end
+
+      private
+
+      def ensure_payment_method_required_params(params)
+        require_param(:type) if params[:type].nil?
+
+        if invalid_type?(params[:type])
+          raise Stripe::InvalidRequestError.new(
+            'Invalid type: must be one of card, ideal or sepa_debit',
+            nil,
+            http_status: 400
+          )
+        end
+      end
+
+      def invalid_type?(type)
+        !%w(card ideal sepa_debit).include?(type)
+      end
+    end
+  end
+end

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

@@ -11,6 +11,7 @@ module StripeMock
 
       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
 

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