epopia-stripe-ruby-mock 2.5.8

data/lib/stripe_mock/request_handlers/balance.rb

@@ -0,0 +1,17 @@
+module StripeMock
+  module RequestHandlers
+    module Balance
+
+      def Balance.included(klass)
+        klass.add_handler 'get /v1/balance',                        :get_balance
+      end
+
+      def get_balance(route, method_url, params, headers)
+        route =~ method_url
+
+        return_balance = Data.mock_balance(account_balance)
+        return_balance
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/balance_transactions.rb

@@ -0,0 +1,37 @@
+module StripeMock
+  module RequestHandlers
+    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
+      end
+
+      def get_balance_transaction(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :balance_transaction, $1, hide_additional_attributes(balance_transactions[$1])
+      end
+
+      def list_balance_transactions(route, method_url, params, headers)
+        values = balance_transactions.values
+        if params.has_key?(:transfer)
+          # If transfer supplied as params, need to filter the btxns returned to only include those with the specified transfer id
+          values = values.select{|btxn| btxn[:transfer] == params[:transfer]}
+        end
+        Data.mock_list_object(values.map{|btxn| hide_additional_attributes(btxn)}, params)
+      end
+
+      private
+
+      def hide_additional_attributes(btxn)
+        # For automatic Stripe transfers, the transfer attribute on balance_transaction stores the transfer which
+        # included this balance_transaction.  However, it is not exposed as a field returned on a balance_transaction.
+        # Therefore, need to not show this attribute if it exists.
+        if !btxn.nil?
+          btxn.reject{|k,v| k == :transfer }
+        end
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/cards.rb

@@ -0,0 +1,35 @@
+module StripeMock
+  module RequestHandlers
+    module Cards
+
+      def Cards.included(klass)
+        klass.add_handler 'get /v1/recipients/(.*)/cards', :retrieve_recipient_cards
+        klass.add_handler 'get /v1/recipients/(.*)/cards/(.*)', :retrieve_recipient_card
+        klass.add_handler 'post /v1/recipients/(.*)/cards', :create_recipient_card
+        klass.add_handler 'delete /v1/recipients/(.*)/cards/(.*)', :delete_recipient_card
+      end
+
+      def create_recipient_card(route, method_url, params, headers)
+        route =~ method_url
+        add_card_to(:recipient, $1, params, recipients)
+      end
+
+      def retrieve_recipient_cards(route, method_url, params, headers)
+        route =~ method_url
+        retrieve_object_cards(:recipient, $1, recipients)
+      end
+
+      def retrieve_recipient_card(route, method_url, params, headers)
+        route =~ method_url
+        recipient = assert_existence :recipient, $1, recipients[$1]
+
+        assert_existence :card, $2, get_card(recipient, $2, "Recipient")
+      end
+
+      def delete_recipient_card(route, method_url, params, headers)
+        route =~ method_url
+        delete_card_from(:recipient, $1, $2, recipients)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/charges.rb

@@ -0,0 +1,177 @@
+module StripeMock
+  module RequestHandlers
+    module Charges
+
+      def Charges.included(klass)
+        klass.add_handler 'post /v1/charges',               :new_charge
+        klass.add_handler 'get /v1/charges',                :get_charges
+        klass.add_handler 'get /v1/charges/(.*)',           :get_charge
+        klass.add_handler 'post /v1/charges/(.*)/capture',  :capture_charge
+        klass.add_handler 'post /v1/charges/(.*)/refund',   :refund_charge
+        klass.add_handler 'post /v1/charges/(.*)/refunds',  :refund_charge
+        klass.add_handler 'post /v1/charges/(.*)',          :update_charge
+      end
+
+      def new_charge(route, method_url, params, headers)
+        if headers && headers[:idempotency_key]
+          params[:idempotency_key] = headers[:idempotency_key]
+          if charges.any?
+            original_charge = charges.values.find { |c| c[:idempotency_key] == headers[:idempotency_key]}
+            return charges[original_charge[:id]] if original_charge
+          end
+        end
+
+        id = new_id('ch')
+
+        if params[:source]
+          if params[:source].is_a?(String)
+            # if a customer is provided, the card parameter is assumed to be the actual
+            # card id, not a token. in this case we'll find the card in the customer
+            # object and return that.
+            if params[:customer]
+              params[:source] = get_card(customers[params[:customer]], params[:source])
+            else
+              params[:source] = get_card_or_bank_by_token(params[:source])
+            end
+          elsif params[:source][:id]
+            raise Stripe::InvalidRequestError.new("Invalid token id: #{params[:source]}", 'card', http_status: 400)
+          end
+        elsif params[:customer]
+          customer = customers[params[:customer]]
+          if customer && customer[:default_source]
+            params[:source] = get_card(customer, customer[:default_source])
+          end
+        end
+
+        ensure_required_params(params)
+        bal_trans_params = { amount: params[:amount], source: id, application_fee: params[:application_fee] }
+
+        balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
+
+        charges[id] = Data.mock_charge(
+            params.merge :id => id,
+            :balance_transaction => balance_transaction_id)
+
+        charge = charges[id].clone
+        if params[:expand] == ['balance_transaction']
+          charge[:balance_transaction] =
+            balance_transactions[balance_transaction_id]
+        end
+
+        charge
+      end
+
+      def update_charge(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        charge = assert_existence :charge, id, charges[id]
+        allowed = allowed_params(params)
+        disallowed = params.keys - allowed
+        if disallowed.count > 0
+          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', http_status: 400)
+        end
+
+        charges[id] = Util.rmerge(charge, params)
+      end
+
+      def get_charges(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = charges.clone
+
+        if params[:customer]
+          clone.delete_if { |k,v| v[:customer] != params[:customer] }
+        end
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      def get_charge(route, method_url, params, headers)
+        route =~ method_url
+        charge_id = $1 || params[:charge]
+        charge = assert_existence :charge, charge_id, charges[charge_id]
+
+        charge = charge.clone
+        if params[:expand] == ['balance_transaction']
+          balance_transaction = balance_transactions[charge[:balance_transaction]]
+          charge[:balance_transaction] = balance_transaction
+        end
+
+        charge
+      end
+
+      def capture_charge(route, method_url, params, headers)
+        route =~ method_url
+        charge = assert_existence :charge, $1, charges[$1]
+
+        if params[:amount]
+          refund = Data.mock_refund(
+            :balance_transaction => new_balance_transaction('txn'),
+            :id => new_id('re'),
+            :amount => charge[:amount] - params[:amount]
+          )
+          add_refund_to_charge(refund, charge)
+        end
+
+        if params[:application_fee]
+          charge[:application_fee] = params[:application_fee]
+        end
+
+        charge[:captured] = true
+        charge
+      end
+
+      def refund_charge(route, method_url, params, headers)
+        charge = get_charge(route, method_url, params, headers)
+
+        new_refund(
+          route,
+          method_url,
+          params.merge(:charge => charge[:id]),
+          headers
+        )
+      end
+
+      private
+
+      def ensure_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)
+        elsif params[:source].nil? && params[:customer].nil?
+          raise Stripe::InvalidRequestError.new('Must provide source or customer.', http_status: nil)
+        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 allowed_params(params)
+        allowed = [:description, :metadata, :receipt_email, :fraud_details, :shipping, :destination]
+
+        # This is a workaround for the way the Stripe API sends params even when they aren't modified.
+        # Stipe will include those params even when they aren't modified.
+        allowed << :fee_details if params.has_key?(:fee_details) && params[:fee_details].nil?
+        allowed << :source if params.has_key?(:source) && params[:source].empty?
+        if params.has_key?(:refunds) && (params[:refunds].empty? ||
+           params[:refunds].has_key?(:data) && params[:refunds][:data].nil?)
+          allowed << :refunds
+        end
+
+        allowed
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/country_spec.rb

@@ -0,0 +1,22 @@
+module StripeMock
+  module RequestHandlers
+    module CountrySpec
+
+      def CountrySpec.included(klass)
+        klass.add_handler 'get /v1/country_specs/(.*)', :retrieve_country_spec
+      end
+
+      def retrieve_country_spec(route, method_url, params, headers)
+        route =~ method_url
+
+        unless ["AT", "AU", "BE", "CA", "DE", "DK", "ES", "FI", "FR", "GB", "IE", "IT", "JP", "LU", "NL", "NO", "SE", "SG", "US"].include?($1)
+          raise Stripe::InvalidRequestError.new("#{$1} is not currently supported by Stripe.", $1.to_s)
+        end
+
+        country_spec[$1] ||= Data.mock_country_spec($1)
+
+        assert_existence :country_spec, $1, country_spec[$1]
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/coupons.rb

@@ -0,0 +1,35 @@
+module StripeMock
+  module RequestHandlers
+    module Coupons
+
+      def Coupons.included(klass)
+        klass.add_handler 'post /v1/coupons',        :new_coupon
+        klass.add_handler 'get /v1/coupons/(.*)',    :get_coupon
+        klass.add_handler 'delete /v1/coupons/(.*)', :delete_coupon
+        klass.add_handler 'get /v1/coupons',         :list_coupons
+      end
+
+      def new_coupon(route, method_url, params, headers)
+        params[:id] ||= new_id('coupon')
+        raise Stripe::InvalidRequestError.new('Missing required param: duration', 'coupon', http_status: 400) unless params[:duration]
+        raise Stripe::InvalidRequestError.new('You must pass currency when passing amount_off', 'coupon', http_status: 400) if params[:amount_off] && !params[:currency]
+        coupons[ params[:id] ] = Data.mock_coupon({amount_off: nil, percent_off:nil}.merge(params))
+      end
+
+      def get_coupon(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :coupon, $1, coupons[$1]
+      end
+
+      def delete_coupon(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :coupon, $1, coupons.delete($1)
+      end
+
+      def list_coupons(route, method_url, params, headers)
+        Data.mock_list_object(coupons.values, params)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/customers.rb

@@ -0,0 +1,137 @@
+module StripeMock
+  module RequestHandlers
+    module Customers
+
+      def Customers.included(klass)
+        klass.add_handler 'post /v1/customers',                     :new_customer
+        klass.add_handler 'post /v1/customers/([^/]*)',             :update_customer
+        klass.add_handler 'get /v1/customers/([^/]*)',              :get_customer
+        klass.add_handler 'delete /v1/customers/([^/]*)',           :delete_customer
+        klass.add_handler 'get /v1/customers',                      :list_customers
+        klass.add_handler 'delete /v1/customers/([^/]*)/discount',  :delete_customer_discount
+      end
+
+      def new_customer(route, method_url, params, headers)
+        params[:id] ||= new_id('cus')
+        sources = []
+
+        if params[:source]
+          new_card =
+            if params[:source].is_a?(Hash)
+              unless params[:source][:object] && params[:source][:number] && params[:source][:exp_month] && params[:source][:exp_year]
+                raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
+              end
+              card_from_params(params[:source])
+            else
+              get_card_or_bank_by_token(params.delete(:source))
+            end
+          sources << new_card
+          params[:default_source] = sources.first[:id]
+        end
+
+        customers[ params[:id] ] = Data.mock_customer(sources, params)
+
+        if params[:plan]
+          plan_id = params[:plan].to_s
+          plan = assert_existence :plan, plan_id, plans[plan_id]
+
+          if params[:default_source].nil? && params[:trial_end].nil? && plan[:trial_period_days].nil? && plan[:amount] != 0
+            raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
+          end
+
+          subscription = Data.mock_subscription({ id: new_id('su') })
+          subscription = resolve_subscription_changes(subscription, [plan], customers[ params[:id] ], params)
+          add_subscription_to_customer(customers[ params[:id] ], subscription)
+          subscriptions[subscription[:id]] = subscription
+        elsif params[:trial_end]
+          raise Stripe::InvalidRequestError.new('Received unknown parameter: trial_end', nil, http_status: 400)
+        end
+
+        if params[:coupon]
+          coupon = coupons[ params[:coupon] ]
+          assert_existence :coupon, params[:coupon], coupon
+
+          add_coupon_to_object(customers[params[:id]], coupon)
+        end
+
+        customers[ params[:id] ]
+      end
+
+      def update_customer(route, method_url, params, headers)
+        route =~ method_url
+        cus = assert_existence :customer, $1, customers[$1]
+
+        # Delete those params if their value is nil. Workaround of the problematic way Stripe serialize objects
+        params.delete(:sources) if params[:sources] && params[:sources][:data].nil?
+        params.delete(:subscriptions) if params[:subscriptions] && params[:subscriptions][:data].nil?
+        # Delete those params if their values aren't valid. Workaround of the problematic way Stripe serialize objects
+        if params[:sources] && !params[:sources][:data].nil?
+          params.delete(:sources) unless params[:sources][:data].any?{ |v| !!v[:type]}
+        end
+        if params[:subscriptions] && !params[:subscriptions][:data].nil?
+          params.delete(:subscriptions) unless params[:subscriptions][:data].any?{ |v| !!v[:type]}
+        end
+        cus.merge!(params)
+
+        if params[:source]
+          if params[:source].is_a?(String)
+            new_card = get_card_or_bank_by_token(params.delete(:source))
+          elsif params[:source].is_a?(Hash)
+            unless params[:source][:object] && params[:source][:number] && params[:source][:exp_month] && params[:source][:exp_year]
+              raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
+            end
+            new_card = card_from_params(params.delete(:source))
+          end
+          add_card_to_object(:customer, new_card, cus, true)
+          cus[:default_source] = new_card[:id]
+        end
+
+        if params[:coupon]
+          coupon = coupons[ params[:coupon] ]
+          assert_existence :coupon, params[:coupon], coupon
+
+          add_coupon_to_object(cus, coupon)
+        end
+
+        cus
+      end
+
+      def delete_customer(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :customer, $1, customers[$1]
+
+        customers[$1] = {
+          id: customers[$1][:id],
+          deleted: true
+        }
+      end
+
+      def get_customer(route, method_url, params, headers)
+        route =~ method_url
+        customer = assert_existence :customer, $1, customers[$1]
+
+        customer = customer.clone
+        if params[:expand] == ['default_source']
+          customer[:default_source] = customer[:sources][:data].detect do |source|
+            source[:id] == customer[:default_source]
+          end
+        end
+
+        customer
+      end
+
+      def list_customers(route, method_url, params, headers)
+        Data.mock_list_object(customers.values, params)
+      end
+
+      def delete_customer_discount(route, method_url, params, headers)
+        route =~ method_url
+        cus = assert_existence :customer, $1, customers[$1]
+
+        cus[:discount] = nil
+
+        cus
+      end
+    end
+  end
+end