stripe-ruby-mock 2.5.6 → 3.1.0.rc2

data/lib/stripe_mock/request_handlers/ephemeral_key.rb

@@ -6,7 +6,7 @@ module StripeMock
       end
 
       def create_ephemeral_key(route, method_url, params, headers)
-        Data.mock_ephemeral_key(params)
+        Data.mock_ephemeral_key(**params)
       end
     end
   end

data/lib/stripe_mock/request_handlers/express_login_links.rb

@@ -0,0 +1,15 @@
+module StripeMock
+  module RequestHandlers
+    module ExpressLoginLinks
+
+      def ExpressLoginLinks.included(klass)
+        klass.add_handler 'post /v1/accounts/(.*)/login_links', :new_account_login_link
+      end
+
+      def new_account_login_link(route, method_url, params, headers)
+        route =~ method_url
+        Data.mock_express_login_link(params)
+      end
+    end
+  end
+end

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

@@ -1,18 +1,22 @@
 module StripeMock
   module RequestHandlers
     module Helpers
+      def add_coupon_to_object(object, coupon)
+        discount_attrs = {}.tap do |attrs|
+          attrs[object[:object]]         = object[:id]
+          attrs[:coupon]                 = coupon
+          attrs[:start]                  = Time.now.to_i
+          attrs[:end]                    = (DateTime.now >> coupon[:duration_in_months].to_i).to_time.to_i if coupon[:duration] == 'repeating'
+        end
 
-      def add_coupon_to_customer(customer, coupon)
-        customer[:discount] = {
-            coupon: coupon,
-            customer: customer[:id],
-            start: Time.now.to_i,
-        }
-        customer[:discount][:end] = (DateTime.now >> coupon[:duration_in_months]).to_time.to_i  if coupon[:duration].to_sym == :repeating && coupon[:duration_in_months]
-
-        customer
+        object[:discount] = Stripe::Discount.construct_from(discount_attrs)
+        object
       end
 
+      def delete_coupon_from_object(object)
+        object[:discount] = nil
+        object
+      end
     end
   end
-end
+end

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

@@ -8,13 +8,16 @@ module StripeMock
 
       def resolve_subscription_changes(subscription, plans, customer, options = {})
         subscription.merge!(custom_subscription_params(plans, customer, options))
+        items = options[:items]
+        items = items.values if items.respond_to?(:values)
         subscription[:items][:data] = plans.map do |plan|
-          if options[:items] && options[:items].size == plans.size
-            quantity = options[:items] &&
-              options[:items].detect { |item| item[:plan] == plan[:id] }[:quantity] || 1
-            Data.mock_subscription_item({ plan: plan, quantity: quantity })
+          matching_item = items && items.detect { |item| [item[:price], item[:plan]].include? plan[:id] }
+          if matching_item
+            quantity = matching_item[:quantity] || 1
+            id = matching_item[:id] || new_id('si')
+            Data.mock_subscription_item({ plan: plan, quantity: quantity, id: id })
           else
-            Data.mock_subscription_item({ plan: plan })
+            Data.mock_subscription_item({ plan: plan, id: new_id('si') })
           end
         end
         subscription
@@ -30,7 +33,15 @@ 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) })
-        params.merge! options.select {|k,v| k =~ /application_fee_percent|quantity|metadata|tax_percent/}
+        keys_to_merge = /application_fee_percent|quantity|metadata|tax_percent|billing|days_until_due|default_tax_rates|pending_invoice_item_interval|default_payment_method|collection_method/
+        params.merge! options.select {|k,v| k =~ keys_to_merge}
+
+        if options[:cancel_at_period_end] == true
+          params.merge!(cancel_at_period_end: true, canceled_at: now)
+        elsif options[:cancel_at_period_end] == false
+          params.merge!(cancel_at_period_end: false, canceled_at: nil)
+        end
+
         # TODO: Implement coupon logic
 
         if (((plan && plan[:trial_period_days]) || 0) == 0 && options[:trial_end].nil?) || options[:trial_end] == "now"
@@ -101,7 +112,11 @@ module StripeMock
 
       def total_items_amount(items)
         total = 0
-        items.each { |i| total += (i[:quantity] || 1) * i[:plan][:amount] }
+        items.each do |item|
+          quantity = item[:quantity] || 1
+          amount = item[:plan][:unit_amount] || item[:plan][:amount]
+          total += quantity * amount
+        end
         total
       end
     end

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,
@@ -138,7 +144,7 @@ module StripeMock
           id: new_id('in'),
           customer: customer[:id],
           discount: customer[:discount],
-          date: invoice_date,
+          created: invoice_date,
           starting_balance: customer[:account_balance],
           subscription: preview_subscription[:id],
           period_start: prorating ? invoice_date : preview_subscription[:current_period_start],

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