epopia-stripe-ruby-mock 2.5.8

data/lib/stripe_mock/data/list.rb

@@ -0,0 +1,73 @@
+module StripeMock
+  module Data
+    class List
+      attr_reader :data, :limit, :offset, :starting_after, :ending_before
+
+      def initialize(data, options = {})
+        @data = Array(data.clone)
+        @limit = [[options[:limit] || 10, 100].min, 1].max # restrict @limit to 1..100
+        @starting_after = options[:starting_after]
+        @ending_before  = options[:ending_before]
+        if @data.first.is_a?(Hash) && @data.first[:created]
+          @data.sort_by! { |x| x[:created] }
+          @data.reverse!
+        elsif @data.first.respond_to?(:created)
+          @data.sort_by { |x| x.created }
+          @data.reverse!
+        end
+      end
+
+      def url
+        "/v1/#{object_types}"
+      end
+
+      def to_hash
+        { object: "list", data: data_page, url: url, has_more: has_more? }
+      end
+      alias_method :to_h, :to_hash
+
+      def has_more?
+        (offset + limit) < data.size
+      end
+
+      def method_missing(method_name, *args, &block)
+        hash = to_hash
+
+        if hash.keys.include?(method_name)
+          hash[method_name]
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_name, priv = false)
+        to_hash.keys.include?(method_name) || super
+      end
+
+      private
+
+      def offset
+        case
+        when starting_after
+          index = data.index { |datum| datum[:id] == starting_after }
+          (index || raise("No such object id: #{starting_after}")) + 1
+        when ending_before
+          index = data.index { |datum| datum[:id] == ending_before }
+          (index || raise("No such object id: #{ending_before}")) - 1          
+        else
+          0
+        end
+      end
+
+      def data_page
+        data[offset, limit]
+      end
+
+      def object_types
+        if first_object = data[0]
+          "#{first_object.class.to_s.split('::')[-1].downcase}s"
+        end
+      end
+    end
+  end
+end

data/lib/stripe_mock/error_queue.rb

@@ -0,0 +1,27 @@
+require 'drb/drb'
+
+module StripeMock
+  class ErrorQueue
+    include DRb::DRbUndumped
+    extend DRb::DRbUndumped
+
+    def initialize
+      @queue = []
+    end
+
+    def queue(error, handler_names)
+      @queue << handler_names.map {|n| [n, error]}
+    end
+
+    def error_for_handler_name(handler_name)
+      return nil if @queue.count == 0
+      triggers = @queue.first
+      (triggers.assoc(:all) || triggers.assoc(handler_name) || [])[1]
+    end
+
+    def dequeue
+      @queue.shift
+    end
+
+  end
+end

data/lib/stripe_mock/errors/closed_client_connection_error.rb

@@ -0,0 +1,9 @@
+module StripeMock
+  class ClosedClientConnectionError < StripeMockError
+
+    def initialize
+      super("This StripeMock client has already been closed.")
+    end
+
+  end
+end

data/lib/stripe_mock/errors/server_timeout_error.rb

@@ -0,0 +1,12 @@
+module StripeMock
+  class ServerTimeoutError < StripeMockError
+
+    attr_reader :associated_error
+
+    def initialize(associated_error)
+      @associated_error = associated_error
+      super("Unable to connect to stripe mock server (did you forget to run `$ stripe-mock-server`?)")
+    end
+
+  end
+end

data/lib/stripe_mock/errors/stripe_mock_error.rb

@@ -0,0 +1,15 @@
+module StripeMock
+  class StripeMockError < StandardError
+
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      @message
+    end
+
+  end
+end

data/lib/stripe_mock/errors/uninitialized_instance_error.rb

@@ -0,0 +1,9 @@
+module StripeMock
+  class UninitializedInstanceError < StripeMockError
+
+    def initialize
+      super("StripeMock instance is nil (did you forget to call `StripeMock.start`?)")
+    end
+
+  end
+end

data/lib/stripe_mock/errors/unstarted_state_error.rb

@@ -0,0 +1,9 @@
+module StripeMock
+  class UnstartedStateError < StripeMockError
+
+    def initialize
+      super("StripeMock has not been started. Please call StripeMock.start or StripeMock.start_client")
+    end
+
+  end
+end

data/lib/stripe_mock/errors/unsupported_request_error.rb

@@ -0,0 +1,4 @@
+module StripeMock
+  class UnsupportedRequestError < StripeMockError
+  end
+end

data/lib/stripe_mock/instance.rb

@@ -0,0 +1,237 @@
+module StripeMock
+  class Instance
+
+    include StripeMock::RequestHandlers::Helpers
+    include StripeMock::RequestHandlers::ParamValidators
+
+    DUMMY_API_KEY = (0...32).map { (65 + rand(26)).chr }.join.downcase
+
+    # Handlers are ordered by priority
+    @@handlers = []
+
+    def self.add_handler(route, name)
+      @@handlers << {
+        :route => %r{^#{route}$},
+        :name => name
+      }
+    end
+
+    def self.handler_for_method_url(method_url)
+      @@handlers.find {|h| method_url =~ h[:route] }
+    end
+
+    include StripeMock::RequestHandlers::PaymentIntents
+    include StripeMock::RequestHandlers::PaymentMethods
+    include StripeMock::RequestHandlers::ExternalAccounts
+    include StripeMock::RequestHandlers::Accounts
+    include StripeMock::RequestHandlers::Balance
+    include StripeMock::RequestHandlers::BalanceTransactions
+    include StripeMock::RequestHandlers::Charges
+    include StripeMock::RequestHandlers::Cards
+    include StripeMock::RequestHandlers::Sources
+    include StripeMock::RequestHandlers::Subscriptions # must be before Customers
+    include StripeMock::RequestHandlers::SubscriptionItems
+    include StripeMock::RequestHandlers::Customers
+    include StripeMock::RequestHandlers::Coupons
+    include StripeMock::RequestHandlers::Disputes
+    include StripeMock::RequestHandlers::Events
+    include StripeMock::RequestHandlers::Invoices
+    include StripeMock::RequestHandlers::InvoiceItems
+    include StripeMock::RequestHandlers::Orders
+    include StripeMock::RequestHandlers::Plans
+    include StripeMock::RequestHandlers::Products
+    include StripeMock::RequestHandlers::Refunds
+    include StripeMock::RequestHandlers::Recipients
+    include StripeMock::RequestHandlers::Transfers
+    include StripeMock::RequestHandlers::Tokens
+    include StripeMock::RequestHandlers::CountrySpec
+    include StripeMock::RequestHandlers::Payouts
+    include StripeMock::RequestHandlers::EphemeralKey
+    include StripeMock::RequestHandlers::TaxRates
+
+    attr_reader :accounts, :balance, :balance_transactions, :bank_tokens, :charges, :coupons, :customers,
+                :disputes, :events, :invoices, :invoice_items, :orders, :payment_intents, :payment_methods,
+                :plans, :recipients, :refunds, :transfers, :payouts, :subscriptions, :country_spec,
+                :subscriptions_items, :products, :tax_rates
+
+    attr_accessor :error_queue, :debug, :conversion_rate, :account_balance
+
+    def initialize
+      @accounts = {}
+      @balance = Data.mock_balance
+      @balance_transactions = Data.mock_balance_transactions(['txn_05RsQX2eZvKYlo2C0FRTGSSA','txn_15RsQX2eZvKYlo2C0ERTYUIA', 'txn_25RsQX2eZvKYlo2C0ZXCVBNM', 'txn_35RsQX2eZvKYlo2C0QAZXSWE', 'txn_45RsQX2eZvKYlo2C0EDCVFRT', 'txn_55RsQX2eZvKYlo2C0OIKLJUY', 'txn_65RsQX2eZvKYlo2C0ASDFGHJ', 'txn_75RsQX2eZvKYlo2C0EDCXSWQ', 'txn_85RsQX2eZvKYlo2C0UJMCDET', 'txn_95RsQX2eZvKYlo2C0EDFRYUI'])
+      @bank_tokens = {}
+      @card_tokens = {}
+      @customers = {}
+      @charges = {}
+      @payment_intents = {}
+      @coupons = {}
+      @disputes = Data.mock_disputes(['dp_05RsQX2eZvKYlo2C0FRTGSSA','dp_15RsQX2eZvKYlo2C0ERTYUIA', 'dp_25RsQX2eZvKYlo2C0ZXCVBNM', 'dp_35RsQX2eZvKYlo2C0QAZXSWE', 'dp_45RsQX2eZvKYlo2C0EDCVFRT', 'dp_55RsQX2eZvKYlo2C0OIKLJUY', 'dp_65RsQX2eZvKYlo2C0ASDFGHJ', 'dp_75RsQX2eZvKYlo2C0EDCXSWQ', 'dp_85RsQX2eZvKYlo2C0UJMCDET', 'dp_95RsQX2eZvKYlo2C0EDFRYUI'])
+      @events = {}
+      @invoices = {}
+      @invoice_items = {}
+      @orders = {}
+      @payment_methods = {}
+      @plans = {}
+      @products = {}
+      @recipients = {}
+      @refunds = {}
+      @transfers = {}
+      @payouts = {}
+      @subscriptions = {}
+      @subscriptions_items = {}
+      @country_spec = {}
+      @tax_rates = {}
+
+      @debug = false
+      @error_queue = ErrorQueue.new
+      @id_counter = 0
+      @balance_transaction_counter = 0
+      @dispute_counter = 0
+      @conversion_rate = 1.0
+      @account_balance = 10000
+
+      # This is basically a cache for ParamValidators
+      @base_strategy = TestStrategies::Base.new
+    end
+
+    def mock_request(method, url, api_key: nil, api_base: nil, params: {}, headers: {})
+      return {} if method == :xtest
+
+      api_key ||= (Stripe.api_key || DUMMY_API_KEY)
+
+      # Ensure params hash has symbols as keys
+      params = Stripe::Util.symbolize_names(params)
+
+      method_url = "#{method} #{url}"
+
+      if handler = Instance.handler_for_method_url(method_url)
+        if @debug == true
+          puts "- - - - " * 8
+          puts "[StripeMock req]::#{handler[:name]} #{method} #{url}"
+          puts "                  #{params}"
+        end
+
+        if mock_error = @error_queue.error_for_handler_name(handler[:name])
+          @error_queue.dequeue
+          raise mock_error
+        else
+          res = self.send(handler[:name], handler[:route], method_url, params, headers)
+          puts "           [res]  #{res}" if @debug == true
+          [to_faraday_hash(res), api_key]
+        end
+      else
+        puts "[StripeMock] Warning : Unrecognized endpoint + method : [#{method} #{url}]"
+        puts "[StripeMock] params: #{params}" unless params.empty?
+        [{}, api_key]
+      end
+    end
+
+    def generate_webhook_event(event_data)
+      event_data[:id] ||= new_id 'evt'
+      @events[ event_data[:id] ] = symbolize_names(event_data)
+    end
+
+    def upsert_stripe_object(object, attributes)
+      # Most Stripe entities can be created via the API.  However, some entities are created when other Stripe entities are
+      # created - such as when BalanceTransactions are created when Charges are created.  This method provides the ability
+      # to create these internal entities.
+      # It also provides the ability to modify existing Stripe entities.
+      id = attributes[:id]
+      if id.nil? || id == ""
+        # Insert new Stripe object
+        case object
+          when :balance_transaction
+            id = new_balance_transaction('txn', attributes)
+          when :dispute
+            id = new_dispute('dp', attributes)
+          else
+            raise UnsupportedRequestError.new "Unsupported stripe object `#{object}`"
+        end
+      else
+        # Update existing Stripe object
+        case object
+          when :balance_transaction
+            btxn = assert_existence :balance_transaction, id, @balance_transactions[id]
+            btxn.merge!(attributes)
+          when :dispute
+            dispute = assert_existence :dispute, id, @disputes[id]
+            dispute.merge!(attributes)
+          else
+            raise UnsupportedRequestError.new "Unsupported stripe object `#{object}`"
+        end
+      end
+      id
+    end
+
+    private
+
+    def assert_existence(type, id, obj, message=nil)
+      if obj.nil?
+        msg = message || "No such #{type}: #{id}"
+        raise Stripe::InvalidRequestError.new(msg, type.to_s, http_status: 404)
+      end
+      obj
+    end
+
+    def new_id(prefix)
+      # Stripe ids must be strings
+      "#{StripeMock.global_id_prefix}#{prefix}_#{@id_counter += 1}"
+    end
+
+    def new_balance_transaction(prefix, params = {})
+      # balance transaction ids must be strings
+      id = "#{StripeMock.global_id_prefix}#{prefix}_#{@balance_transaction_counter += 1}"
+      amount = params[:amount]
+      unless amount.nil?
+        # Fee calculation
+        calculate_fees(params) unless params[:fee]
+        params[:net] = amount - params[:fee]
+        params[:amount] = amount * @conversion_rate
+      end
+      @balance_transactions[id] = Data.mock_balance_transaction(params.merge(id: id))
+      id
+    end
+
+    def new_dispute(prefix, params = {})
+      id = "#{StripeMock.global_id_prefix}#{prefix}_#{@dispute_counter += 1}"
+      @disputes[id] = Data.mock_dispute(params.merge(id: id))
+      id
+    end
+
+    def symbolize_names(hash)
+      Stripe::Util.symbolize_names(hash)
+    end
+
+    def to_faraday_hash(hash)
+      response = Struct.new(:data)
+      response.new(hash)
+    end
+
+    def calculate_fees(params)
+      application_fee = params[:application_fee] || 0
+      params[:fee] = processing_fee(params[:amount]) + application_fee
+      params[:fee_details] = [
+        {
+          amount: processing_fee(params[:amount]),
+          application: nil,
+          currency: params[:currency] || StripeMock.default_currency,
+          description: "Stripe processing fees",
+          type: "stripe_fee"
+        }
+      ]
+      if application_fee
+        params[:fee_details] << {
+          amount: application_fee,
+          currency: params[:currency] || StripeMock.default_currency,
+          description: "Application fee",
+          type: "application_fee"
+        }
+      end
+    end
+
+    def processing_fee(amount)
+      (30 + (amount.abs * 0.029).ceil) * (amount > 0 ? 1 : -1)
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/accounts.rb

@@ -0,0 +1,86 @@
+module StripeMock
+  module RequestHandlers
+    module Accounts
+      VALID_START_YEAR = 2009
+
+      def Accounts.included(klass)
+        klass.add_handler 'post /v1/accounts',      :new_account
+        klass.add_handler 'get /v1/account',        :get_account
+        klass.add_handler 'get /v1/accounts/(.*)',  :get_account
+        klass.add_handler 'post /v1/accounts/(.*)', :update_account
+        klass.add_handler 'get /v1/accounts',       :list_accounts
+        klass.add_handler 'post /oauth/deauthorize',:deauthorize
+      end
+
+      def new_account(route, method_url, params, headers)
+        params[:id] ||= new_id('acct')
+        route =~ method_url
+        accounts[params[:id]] ||= Data.mock_account(params)
+      end
+
+      def get_account(route, method_url, params, headers)
+        route =~ method_url
+        init_account
+        id = $1 || accounts.keys[0]
+        assert_existence :account, id, accounts[id]
+      end
+
+      def update_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+        account.merge!(params)
+        if blank_value?(params[:tos_acceptance], :date)
+          raise Stripe::InvalidRequestError.new("Invalid integer: ", "tos_acceptance[date]", http_status: 400)
+        elsif params[:tos_acceptance] && params[:tos_acceptance][:date]
+          validate_acceptance_date(params[:tos_acceptance][:date])
+        end
+        account
+      end
+
+      def list_accounts(route, method_url, params, headers)
+        init_account
+        Data.mock_list_object(accounts.values, params)
+      end
+
+      def deauthorize(route, method_url, params, headers)
+        init_account
+        route =~ method_url
+        Stripe::StripeObject.construct_from(:stripe_user_id => params[:stripe_user_id])
+      end
+
+      private
+
+      def init_account
+        if accounts == {}
+          acc = Data.mock_account
+          accounts[acc[:id]] = acc
+        end
+      end
+
+      # Checks if setting a blank value
+      #
+      # returns true if the key is included in the hash
+      # and its value is empty or nil
+      def blank_value?(hash, key)
+        if hash.key?(key)
+          value = hash[key]
+          return true if value.nil? || "" == value
+        end
+        false
+      end
+
+      def validate_acceptance_date(unix_date)
+        unix_now = Time.now.strftime("%s").to_i
+        formatted_date = Time.at(unix_date)
+
+        return if formatted_date.year >= VALID_START_YEAR && unix_now >= unix_date
+
+        raise Stripe::InvalidRequestError.new(
+          "ToS acceptance date is not valid. Dates are expected to be integers, measured in seconds, not in the future, and after 2009",
+          "tos_acceptance[date]", 
+          http_status: 400
+        )
+      end
+    end
+  end
+end