epopia-stripe-ruby-mock 2.5.8

data/lib/stripe_mock/request_handlers/payment_methods.rb

@@ -0,0 +1,112 @@
+module StripeMock
+  module RequestHandlers
+    module PaymentMethods
+      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
+
+      # 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)
+        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/payouts.rb

@@ -0,0 +1,32 @@
+module StripeMock
+  module RequestHandlers
+    module Payouts
+
+      def Payouts.included(klass)
+        klass.add_handler 'post /v1/payouts',            :new_payout
+        klass.add_handler 'get /v1/payouts',             :list_payouts
+        klass.add_handler 'get /v1/payouts/(.*)',        :get_payout
+      end
+
+      def new_payout(route, method_url, params, headers)
+        id = new_id('po')
+
+        unless params[:amount].is_a?(Integer) || (params[:amount].is_a?(String) && /^\d+$/.match(params[:amount]))
+          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', http_status: 400)
+        end
+
+        payouts[id] = Data.mock_payout(params.merge :id => id)
+      end
+
+      def list_payouts(route, method_url, params, headers)
+        Data.mock_list_object(payouts.clone.values, params)
+      end
+
+      def get_payout(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :payout, $1, payouts[$1]
+        payouts[$1] ||= Data.mock_payout(:id => $1)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/plans.rb

@@ -0,0 +1,42 @@
+module StripeMock
+  module RequestHandlers
+    module Plans
+
+      def Plans.included(klass)
+        klass.add_handler 'post /v1/plans',        :new_plan
+        klass.add_handler 'post /v1/plans/(.*)',   :update_plan
+        klass.add_handler 'get /v1/plans/(.*)',    :get_plan
+        klass.add_handler 'delete /v1/plans/(.*)', :delete_plan
+        klass.add_handler 'get /v1/plans',         :list_plans
+      end
+
+      def new_plan(route, method_url, params, headers)
+        params[:id] ||= new_id('plan')
+        validate_create_plan_params(params)
+        plans[ params[:id] ] = Data.mock_plan(params)
+      end
+
+      def update_plan(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :plan, $1, plans[$1]
+        plans[$1].merge!(params)
+      end
+
+      def get_plan(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :plan, $1, plans[$1]
+      end
+
+      def delete_plan(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :plan, $1, plans.delete($1)
+      end
+
+      def list_plans(route, method_url, params, headers)
+        limit = params[:limit] ? params[:limit] : 10
+        Data.mock_list_object(plans.values.first(limit), limit: limit)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/products.rb

@@ -0,0 +1,43 @@
+module StripeMock
+  module RequestHandlers
+    module Products
+      def self.included(base)
+        base.add_handler 'post /v1/products',        :create_product
+        base.add_handler 'get /v1/products/(.*)',    :retrieve_product
+        base.add_handler 'post /v1/products/(.*)',   :update_product
+        base.add_handler 'get /v1/products',         :list_products
+        base.add_handler 'delete /v1/products/(.*)', :destroy_product
+      end
+
+      def create_product(_route, _method_url, params, _headers)
+        params[:id] ||= new_id('prod')
+        products[params[:id]] = Data.mock_product(params)
+      end
+
+      def retrieve_product(route, method_url, _params, _headers)
+        id = method_url.match(route).captures.first
+        assert_existence :product, id, products[id]
+      end
+
+      def update_product(route, method_url, params, _headers)
+        id = method_url.match(route).captures.first
+        product = assert_existence :product, id, products[id]
+
+        product.merge!(params)
+      end
+
+      def list_products(_route, _method_url, params, _headers)
+        limit = params[:limit] || 10
+        Data.mock_list_object(products.values.take(limit), params)
+      end
+
+      def destroy_product(route, method_url, _params, _headers)
+        id = method_url.match(route).captures.first
+        assert_existence :product, id, products[id]
+
+        products.delete(id)
+        { id: id, object: 'product', deleted: true }
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/recipients.rb

@@ -0,0 +1,60 @@
+module StripeMock
+  module RequestHandlers
+    module Recipients
+
+      def Recipients.included(klass)
+        klass.add_handler 'post /v1/recipients',            :new_recipient
+        klass.add_handler 'post /v1/recipients/(.*)',       :update_recipient
+        klass.add_handler 'get /v1/recipients/(.*)',        :get_recipient
+      end
+
+      def new_recipient(route, method_url, params, headers)
+        params[:id] ||= new_id('rp')
+        cards = []
+
+        if params[:name].nil?
+          raise StripeMock::StripeMockError.new("Missing required parameter name for recipients.")
+        end
+
+        if params[:type].nil?
+          raise StripeMock::StripeMockError.new("Missing required parameter type for recipients.")
+        end
+
+        unless %w(individual corporation).include?(params[:type])
+          raise StripeMock::StripeMockError.new("Type must be either individual or corporation..")
+        end
+
+        if params[:bank_account]
+          params[:active_account] = get_bank_by_token(params.delete(:bank_account))
+        end
+
+        if params[:card]
+          cards << get_card_by_token(params.delete(:card))
+          params[:default_card] = cards.first[:id]
+        end
+
+        recipients[ params[:id] ] = Data.mock_recipient(cards, params)
+        recipients[ params[:id] ]
+      end
+
+      def update_recipient(route, method_url, params, headers)
+        route =~ method_url
+        recipient = assert_existence :recipient, $1, recipients[$1]
+        recipient.merge!(params)
+
+        if params[:card]
+          new_card = get_card_by_token(params.delete(:card))
+          add_card_to_object(:recipient, new_card, recipient, true)
+          recipient[:default_card] = new_card[:id]
+        end
+
+        recipient
+      end
+
+      def get_recipient(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :recipient, $1, recipients[$1]
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/refunds.rb

@@ -0,0 +1,91 @@
+module StripeMock
+  module RequestHandlers
+    module Refunds
+
+      def Refunds.included(klass)
+        klass.add_handler 'post /v1/refunds',               :new_refund
+        klass.add_handler 'get /v1/refunds',                :get_refunds
+        klass.add_handler 'get /v1/refunds/(.*)',           :get_refund
+        klass.add_handler 'post /v1/refunds/(.*)',          :update_refund
+      end
+
+      def new_refund(route, method_url, params, headers)
+        if headers && headers[:idempotency_key]
+          params[:idempotency_key] = headers[:idempotency_key]
+          if refunds.any?
+            original_refund = refunds.values.find { |c| c[:idempotency_key] == headers[:idempotency_key]}
+            return refunds[original_refund[:id]] if original_refund
+          end
+        end
+
+        charge = assert_existence :charge, params[:charge], charges[params[:charge]]
+        params[:amount] ||= charge[:amount]
+        id = new_id('re')
+        bal_trans_params = {
+          amount: params[:amount] * -1,
+          source: id,
+          type: 'refund'
+        }
+        balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
+        refund = Data.mock_refund params.merge(
+          :balance_transaction => balance_transaction_id,
+          :id => id,
+          :charge => charge[:id],
+        )
+        add_refund_to_charge(refund, charge)
+        refunds[id] = refund
+
+        if params[:expand] == ['balance_transaction']
+          refunds[id][:balance_transaction] =
+            balance_transactions[balance_transaction_id]
+        end
+        refund
+      end
+
+      def update_refund(route, method_url, params, headers)
+        route =~ method_url
+        id = $1
+
+        refund = assert_existence :refund, id, refunds[id]
+        allowed = allowed_refund_params(params)
+        disallowed = params.keys - allowed
+        if disallowed.count > 0
+          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', http_status: 400)
+        end
+
+        refunds[id] = Util.rmerge(refund, params)
+      end
+
+      def get_refunds(route, method_url, params, headers)
+        params[:offset] ||= 0
+        params[:limit] ||= 10
+
+        clone = refunds.clone
+
+        Data.mock_list_object(clone.values, params)
+      end
+
+      def get_refund(route, method_url, params, headers)
+        route =~ method_url
+        refund_id = $1 || params[:refund]
+        assert_existence :refund, refund_id, refunds[refund_id]
+      end
+
+      private
+
+      def ensure_refund_required_params(params)
+        if 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[:charge].nil?
+          raise Stripe::InvalidRequestError.new('Must provide the identifier of the charge to refund.', nil)
+        end
+      end
+
+      def allowed_refund_params(params)
+        [:metadata]
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/sources.rb

@@ -0,0 +1,55 @@
+module StripeMock
+  module RequestHandlers
+    module Sources
+
+      def Sources.included(klass)
+        klass.add_handler 'get /v1/customers/(.*)/sources', :retrieve_sources
+        klass.add_handler 'post /v1/customers/(.*)/sources', :create_source
+        klass.add_handler 'post /v1/customers/(.*)/sources/(.*)/verify', :verify_source
+        klass.add_handler 'get /v1/customers/(.*)/sources/(.*)', :retrieve_source
+        klass.add_handler 'delete /v1/customers/(.*)/sources/(.*)', :delete_source
+        klass.add_handler 'post /v1/customers/(.*)/sources/(.*)', :update_source
+      end
+
+      def create_source(route, method_url, params, headers)
+        route =~ method_url
+        add_source_to(:customer, $1, params, customers)
+      end
+
+      def retrieve_sources(route, method_url, params, headers)
+        route =~ method_url
+        retrieve_object_cards(:customer, $1, customers)
+      end
+
+      def retrieve_source(route, method_url, params, headers)
+        route =~ method_url
+        customer = assert_existence :customer, $1, customers[$1]
+
+        assert_existence :card, $2, get_card(customer, $2)
+      end
+
+      def delete_source(route, method_url, params, headers)
+        route =~ method_url
+        delete_card_from(:customer, $1, $2, customers)
+      end
+
+      def update_source(route, method_url, params, headers)
+        route =~ method_url
+        customer = assert_existence :customer, $1, customers[$1]
+
+        card = assert_existence :card, $2, get_card(customer, $2)
+        card.merge!(params)
+        card
+      end
+
+      def verify_source(route, method_url, params, headers)
+        route =~ method_url
+        customer = assert_existence :customer, $1, customers[$1]
+
+        bank_account = assert_existence :bank_account, $2, verify_bank_account(customer, $2)
+        bank_account
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/subscription_items.rb

@@ -0,0 +1,36 @@
+module StripeMock
+  module RequestHandlers
+    module SubscriptionItems
+
+      def SubscriptionItems.included(klass)
+        klass.add_handler 'get /v1/subscription_items', :retrieve_subscription_items
+        klass.add_handler 'post /v1/subscription_items/([^/]*)', :update_subscription_item
+        klass.add_handler 'post /v1/subscription_items', :create_subscription_items
+      end
+
+      def retrieve_subscription_items(route, method_url, params, headers)
+        route =~ method_url
+
+        require_param(:subscription) unless params[:subscription]
+
+        Data.mock_list_object(subscriptions_items, params)
+      end
+
+      def create_subscription_items(route, method_url, params, headers)
+        params[:id] ||= new_id('si')
+
+        require_param(:subscription) unless params[:subscription]
+        require_param(:plan) unless params[:plan]
+
+        subscriptions_items[params[:id]] = Data.mock_subscription_item(params.merge(plan: plans[params[:plan]]))
+      end
+
+      def update_subscription_item(route, method_url, params, headers)
+        route =~ method_url
+
+        subscription_item = assert_existence :subscription_item, $1, subscriptions_items[$1]
+        subscription_item.merge!(params.merge(plan: plans[params[:plan]]))
+      end
+    end
+  end
+end