stripe-ruby-mock 2.5.8 → 3.0.0

data/lib/stripe_mock/request_handlers/balance_transactions.rb

@@ -3,8 +3,8 @@ module StripeMock
     module BalanceTransactions
 
       def BalanceTransactions.included(klass)
-        klass.add_handler 'get /v1/balance/history/(.*)',  :get_balance_transaction
-        klass.add_handler 'get /v1/balance/history',       :list_balance_transactions
+        klass.add_handler 'get /v1/balance_transactions/(.*)',  :get_balance_transaction
+        klass.add_handler 'get /v1/balance_transactions',       :list_balance_transactions
       end
 
       def get_balance_transaction(route, method_url, params, headers)

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

@@ -32,7 +32,7 @@ module StripeMock
         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/
+        keys_to_merge = /application_fee_percent|quantity|metadata|tax_percent|billing|days_until_due|default_tax_rates/
         params.merge! options.select {|k,v| k =~ keys_to_merge}
 
         if options[:cancel_at_period_end] == true

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

@@ -99,7 +99,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,175 @@
+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'
+        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)
+        payment_intent
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/payment_methods.rb

@@ -0,0 +1,138 @@
+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
+
+      #
+      # params: {:customer=>"test_cus_3"}
+      #
+      def attach_payment_method(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+        payment_methods[id].merge!(params)
+        payment_methods[id].clone
+      end
+
+      def detach_payment_method(route, method_url, params, headers)
+
+      end
+
+      def get_payment_method(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+        assert_existence(:payment_method, $1, payment_methods[id])
+      end
+      
+      # post /v1/payment_methods/:id/attach
+      def attach_payment_method(route, method_url, params, headers)
+        allowed_params = [:customer]
+
+        id = method_url.match(route)[1]
+
+        assert_existence :customer, params[:customer], customers[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, :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.',
+            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 or card_present',
+            http_status: 400
+          )
+        end
+      end
+
+      def invalid_type?(type)
+        !['card', 'card_present'].include?(type)
+      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