epopia-stripe-ruby-mock 2.5.8

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

@@ -0,0 +1,44 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def generate_bank_token(bank_params = {})
+        token = new_id 'btok'
+        bank_params[:id] = new_id 'bank_account'
+        @bank_tokens[token] = Data.mock_bank_account bank_params
+        token
+      end
+
+      def generate_card_token(card_params = {})
+        token = new_id 'tok'
+        card_params[:id] = new_id 'cc'
+        @card_tokens[token] = Data.mock_card symbolize_names(card_params)
+        token
+      end
+
+      def get_bank_by_token(token)
+        if token.nil? || @bank_tokens[token].nil?
+          Data.mock_bank_account
+        else
+          @bank_tokens.delete(token)
+        end
+      end
+
+      def get_card_by_token(token)
+        if token.nil? || @card_tokens[token].nil?
+          # TODO: Make this strict
+          msg = "Invalid token id: #{token}"
+          raise Stripe::InvalidRequestError.new(msg, 'tok', http_status: 404)
+        else
+          @card_tokens.delete(token)
+        end
+      end
+
+      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))
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/invoice_items.rb

@@ -0,0 +1,45 @@
+module StripeMock
+  module RequestHandlers
+    module InvoiceItems
+
+      def InvoiceItems.included(klass)
+        klass.add_handler 'post /v1/invoiceitems',        :new_invoice_item
+        klass.add_handler 'post /v1/invoiceitems/(.*)',   :update_invoice_item
+        klass.add_handler 'get /v1/invoiceitems/(.*)',    :get_invoice_item
+        klass.add_handler 'get /v1/invoiceitems',         :list_invoice_items
+        klass.add_handler 'delete /v1/invoiceitems/(.*)', :delete_invoice_item
+      end
+
+      def new_invoice_item(route, method_url, params, headers)
+        params[:id] ||= new_id('ii')
+        invoice_items[params[:id]] = Data.mock_invoice_item(params)
+      end
+
+      def update_invoice_item(route, method_url, params, headers)
+        route =~ method_url
+        list_item = assert_existence :list_item, $1, invoice_items[$1]
+        list_item.merge!(params)
+      end
+
+      def delete_invoice_item(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :list_item, $1, invoice_items[$1]
+
+        invoice_items[$1] = {
+          id: invoice_items[$1][:id],
+          deleted: true
+        }
+      end
+
+      def list_invoice_items(route, method_url, params, headers)
+        Data.mock_list_object(invoice_items.values, params)
+      end
+
+      def get_invoice_item(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :invoice_item, $1, invoice_items[$1]
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -0,0 +1,177 @@
+module StripeMock
+  module RequestHandlers
+    module Invoices
+
+      def Invoices.included(klass)
+        klass.add_handler 'post /v1/invoices',               :new_invoice
+        klass.add_handler 'get /v1/invoices/upcoming',       :upcoming_invoice
+        klass.add_handler 'get /v1/invoices/(.*)/lines',     :get_invoice_line_items
+        klass.add_handler 'get /v1/invoices/(.*)',           :get_invoice
+        klass.add_handler 'get /v1/invoices',                :list_invoices
+        klass.add_handler 'post /v1/invoices/(.*)/pay',      :pay_invoice
+        klass.add_handler 'post /v1/invoices/(.*)',          :update_invoice
+      end
+
+      def new_invoice(route, method_url, params, headers)
+        id = new_id('in')
+        invoice_item = Data.mock_line_item()
+        invoices[id] = Data.mock_invoice([invoice_item], params.merge(:id => id))
+      end
+
+      def update_invoice(route, method_url, params, headers)
+        route =~ method_url
+        params.delete(:lines) if params[:lines]
+        assert_existence :invoice, $1, invoices[$1]
+        invoices[$1].merge!(params)
+      end
+
+      def list_invoices(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        result = invoices.clone
+
+        if params[:customer]
+          result.delete_if { |k,v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(result.values, params)
+      end
+
+      def get_invoice(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :invoice, $1, invoices[$1]
+      end
+
+      def get_invoice_line_items(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :invoice, $1, invoices[$1]
+        invoices[$1][:lines]
+      end
+
+      def pay_invoice(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :invoice, $1, invoices[$1]
+        charge = invoice_charge(invoices[$1])
+        invoices[$1].merge!(:paid => true, :attempted => true, :charge => charge[:id])
+      end
+
+      def upcoming_invoice(route, method_url, params, headers)
+        route =~ method_url
+        raise Stripe::InvalidRequestError.new('Missing required param: customer', nil, http_status: 400) if params[:customer].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]]
+        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
+
+        subscription =
+          if params[:subscription]
+            customer[:subscriptions][:data].select{|s|s[:id] == params[:subscription]}.first
+          else
+            customer[:subscriptions][:data].min_by { |sub| sub[:current_period_end] }
+          end
+
+        if params[:subscription_proration_date] && !((subscription[:current_period_start]..subscription[:current_period_end]) === params[:subscription_proration_date])
+          raise Stripe::InvalidRequestError.new('Cannot specify proration date outside of current subscription period', nil, http_status: 400)
+        end
+
+        prorating = false
+        subscription_proration_date = nil
+        subscription_plan_id = params[:subscription_plan] || subscription[:plan][:id]
+        subscription_quantity = params[:subscription_quantity] || subscription[:quantity]
+        if subscription_plan_id != subscription[:plan][:id] || subscription_quantity != subscription[:quantity]
+          prorating = true
+          invoice_date = Time.now.to_i
+          subscription_plan = assert_existence :plan, subscription_plan_id, plans[subscription_plan_id.to_s]
+          preview_subscription = Data.mock_subscription
+          preview_subscription = resolve_subscription_changes(preview_subscription, [subscription_plan], customer, { trial_end: params[:subscription_trial_end] })
+          preview_subscription[:id] = subscription[:id]
+          preview_subscription[:quantity] = subscription_quantity
+          subscription_proration_date = params[:subscription_proration_date] || Time.now
+        else
+          preview_subscription = subscription
+          invoice_date = subscription[:current_period_end]
+        end
+
+        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])
+          invoice_lines << Data.mock_line_item(
+                                   id: new_id('ii'),
+                                   amount: -unused_amount,
+                                   description: 'Unused time',
+                                   plan: subscription[:plan],
+                                   period: {
+                                       start: subscription_proration_date.to_i,
+                                       end: subscription[:current_period_end]
+                                   },
+                                   quantity: subscription[:quantity],
+                                   proration: true
+          )
+
+          preview_plan = assert_existence :plan, params[:subscription_plan], plans[params[:subscription_plan]]
+          if preview_plan[:interval] == subscription[:plan][:interval] && preview_plan[:interval_count] == subscription[:plan][:interval_count] && params[:subscription_trial_end].nil?
+            remaining_amount = preview_plan[:amount] * subscription_quantity * (subscription[:current_period_end] - subscription_proration_date.to_i) / (subscription[:current_period_end] - subscription[:current_period_start])
+            invoice_lines << Data.mock_line_item(
+                                     id: new_id('ii'),
+                                     amount: remaining_amount,
+                                     description: 'Remaining time',
+                                     plan: preview_plan,
+                                     period: {
+                                         start: subscription_proration_date.to_i,
+                                         end: subscription[:current_period_end]
+                                     },
+                                     quantity: subscription_quantity,
+                                     proration: true
+            )
+          end
+        end
+
+        subscription_line = get_mock_subscription_line_item(preview_subscription)
+        invoice_lines << subscription_line
+
+        Data.mock_invoice(invoice_lines,
+          id: new_id('in'),
+          customer: customer[:id],
+          discount: customer[:discount],
+          created: invoice_date,
+          starting_balance: customer[:account_balance],
+          subscription: preview_subscription[:id],
+          period_start: prorating ? invoice_date : preview_subscription[:current_period_start],
+          period_end: prorating ? invoice_date : preview_subscription[:current_period_end],
+          next_payment_attempt: preview_subscription[:current_period_end] + 3600 )
+      end
+
+      private
+
+      def get_mock_subscription_line_item(subscription)
+        Data.mock_line_item(
+          id: subscription[:id],
+          type: "subscription",
+          plan: subscription[:plan],
+          amount: subscription[:status] == 'trialing' ? 0 : subscription[:plan][:amount] * subscription[:quantity],
+          discountable: true,
+          quantity: subscription[:quantity],
+          period: {
+            start: subscription[:current_period_end],
+            end: get_ending_time(subscription[:current_period_start], subscription[:plan], 2)
+          })
+      end
+
+      ## charge the customer on the invoice, if one does not exist, create
+      #anonymous charge
+      def invoice_charge(invoice)
+        begin
+          new_charge(nil, nil, {customer: invoice[:customer]["id"], amount: invoice[:amount_due], currency: StripeMock.default_currency}, nil)
+        rescue Stripe::InvalidRequestError
+          new_charge(nil, nil, {source: generate_card_token, amount: invoice[:amount_due], currency: StripeMock.default_currency}, nil)
+        end
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/orders.rb

@@ -0,0 +1,80 @@
+module StripeMock
+  module RequestHandlers
+    module Orders
+
+      def Orders.included(klass)
+        klass.add_handler 'post /v1/orders',                     :new_order
+        klass.add_handler 'post /v1/orders/(.*)/pay',            :pay_order
+        klass.add_handler 'post /v1/orders/(.*)',                :update_order
+        klass.add_handler 'get /v1/orders/(.*)',                 :get_order
+        klass.add_handler 'get /v1/orders',                      :list_orders
+      end
+
+      def new_order(route, method_url, params, headers)
+        params[:id] ||= new_id('or')
+        order_items = []
+
+        unless params[:currency].to_s.size == 3
+          raise Stripe::InvalidRequestError.new('You must supply a currency', nil, http_status: 400)
+        end
+
+        if params[:items]
+          unless params[:items].is_a? Array
+            raise Stripe::InvalidRequestError.new('You must supply a list of items', nil, http_status: 400)
+          end
+
+          unless params[:items].first.is_a? Hash
+            raise Stripe::InvalidRequestError.new('You must supply an item', nil, http_status: 400)
+          end
+        end
+
+        orders[ params[:id] ] = Data.mock_order(order_items, params)
+
+        orders[ params[:id] ]
+      end
+
+      def update_order(route, method_url, params, headers)
+        route =~ method_url
+        order = assert_existence :order, $1, orders[$1]
+
+        if params[:metadata]
+          if params[:metadata].empty?
+            order[:metadata] = {}
+          else
+            order[:metadata].merge(params[:metadata])
+          end
+        end
+
+        if %w(created paid canceled fulfilled returned).include? params[:status]
+          order[:status] = params[:status]
+        end
+        order
+      end
+
+      def get_order(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :order, $1, orders[$1]
+      end
+
+      def pay_order(route, method_url, params, headers)
+        route =~ method_url
+        order = assert_existence :order, $1, orders[$1]
+
+        if params[:source].blank? && params[:customer].blank?
+          raise Stripe::InvalidRequestError.new('You must supply a source or customer', nil, http_status: 400)
+        end
+
+        charge_id = new_id('ch')
+        charges[charge_id] = Data.mock_charge(id: charge_id)
+        order[:charge] = charge_id
+        order[:status] = "paid"
+        order
+      end
+
+      def list_orders(route, method_url, params, headers)
+        Data.mock_list_object(orders.values, params)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/payment_intents.rb

@@ -0,0 +1,203 @@
+module StripeMock
+  module RequestHandlers
+    module PaymentIntents
+      FAILED_TRANSACTION_AMOUNT = 3178
+      REQUIRES_ACTION_AMOUNT = 3184
+      REQUIRES_CAPTURE_AMOUNT = 3169
+
+      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 REQUIRES_ACTION_AMOUNT then 'requires_action'
+        when FAILED_TRANSACTION_AMOUNT then 'requires_payment_method'
+        when REQUIRES_CAPTURE_AMOUNT then 'requires_capture'
+        else
+          'succeeded'
+        end
+        last_payment_error = params[:amount] == FAILED_TRANSACTION_AMOUNT ? last_payment_error_generator(code: 'card_declined', decline_code: 'insufficient_funds', message: 'Not enough funds.') : nil
+        next_action = params[:amount] == REQUIRES_ACTION_AMOUNT ? { type: "use_stripe_sdk" } : nil
+        payment_intents[id] = Data.mock_payment_intent(
+          params.merge(
+            id: id,
+            status: status,
+            last_payment_error: last_payment_error,
+            next_action: next_action,
+            charges: status == 'succeeded' ? charges_data(params[:amount], params[:currency]) : empty_charges
+          )
+        )
+
+        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]
+
+        payment_intent[:status] = payment_intent[:amount] == FAILED_TRANSACTION_AMOUNT ? 'requires_payment_method' : 'succeeded'
+        payment_intent[:last_payment_error] = payment_intent[:status] == 'requires_payment_method' ? last_payment_error_generator(code: 'card_declined', decline_code: 'do_not_honor', message: 'Your card has been declined. Please contact your bank for more information.') : nil
+        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]
+
+        payment_intent[:status] = 'succeeded'
+        payment_intent[:charges] = charges_data(payment_intent[:amount], payment_intent[:currency])
+        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 charges_data(amount, currency)
+        payment_intent_charge_id = new_id('ch')
+        payment_intent_charge = Data.mock_charge(
+          id: payment_intent_charge_id,
+          amount: amount,
+          currency: currency
+        )
+        charges[payment_intent_charge_id] = payment_intent_charge
+        {
+          :data => [payment_intent_charge],
+          :object => 'list',
+          has_more: false,
+          total_count: 1,
+          url: "/v1/charges?payment_intent=pi_1EwXFB2eZvKYlo2CggNnFBo8"
+        }
+      end
+
+      def empty_charges()
+        {
+          object: "list",
+          data: [],
+          has_more: false,
+          total_count: 0,
+          url: "/v1/charges?payment_intent=pi_1EwXFB2eZvKYlo2CggNnFBo8"
+        }
+      end
+
+      def last_payment_error_generator(code:, message:, decline_code:)
+        {
+          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
+    end
+  end
+end