epopia-stripe-ruby-mock 2.5.8

data/lib/stripe_mock/request_handlers/disputes.rb

@@ -0,0 +1,35 @@
+module StripeMock
+  module RequestHandlers
+    module Disputes
+
+      def Disputes.included(klass)
+        klass.add_handler 'get /v1/disputes/(.*)',        :get_dispute
+        klass.add_handler 'post /v1/disputes/(.*)/close', :close_dispute
+        klass.add_handler 'post /v1/disputes/(.*)',       :update_dispute
+        klass.add_handler 'get /v1/disputes',             :list_disputes   
+      end
+
+      def get_dispute(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :dispute, $1, disputes[$1]
+      end
+
+      def update_dispute(route, method_url, params, headers)
+        dispute = get_dispute(route, method_url, params, headers)
+        dispute.merge!(params)
+        dispute
+      end
+
+      def close_dispute(route, method_url, params, headers)
+        dispute = get_dispute(route, method_url, params, headers)
+        dispute.merge!({:status => 'lost'})
+        dispute
+      end
+
+      def list_disputes(route, method_url, params, headers)
+        Data.mock_list_object(disputes.values, params)
+      end
+
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/ephemeral_key.rb

@@ -0,0 +1,13 @@
+module StripeMock
+  module RequestHandlers
+    module EphemeralKey
+      def self.included(klass)
+        klass.add_handler 'post /v1/ephemeral_keys', :create_ephemeral_key
+      end
+
+      def create_ephemeral_key(route, method_url, params, headers)
+        Data.mock_ephemeral_key(params)
+      end
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/events.rb

@@ -0,0 +1,21 @@
+module StripeMock
+  module RequestHandlers
+    module Events
+
+      def Events.included(klass)
+        klass.add_handler 'get /v1/events/(.*)', :retrieve_event
+        klass.add_handler 'get /v1/events',      :list_events 
+      end
+
+      def retrieve_event(route, method_url, params, headers)
+        route =~ method_url
+        assert_existence :event, $1, events[$1]
+      end
+
+      def list_events(route, method_url, params, headers)
+        Data.mock_list_object(events.values, params)
+      end
+      
+    end
+  end
+end

data/lib/stripe_mock/request_handlers/external_accounts.rb

@@ -0,0 +1,55 @@
+module StripeMock
+  module RequestHandlers
+    module ExternalAccounts
+
+      def ExternalAccounts.included(klass)
+        klass.add_handler 'get /v1/accounts/(.*)/external_accounts', :retrieve_external_accounts
+        klass.add_handler 'post /v1/accounts/(.*)/external_accounts', :create_external_account
+        klass.add_handler 'post /v1/accounts/(.*)/external_accounts/(.*)/verify', :verify_external_account
+        klass.add_handler 'get /v1/accounts/(.*)/external_accounts/(.*)', :retrieve_external_account
+        klass.add_handler 'delete /v1/accounts/(.*)/external_accounts/(.*)', :delete_external_account
+        klass.add_handler 'post /v1/accounts/(.*)/external_accounts/(.*)', :update_external_account
+      end
+
+      def create_external_account(route, method_url, params, headers)
+        route =~ method_url
+        add_external_account_to(:account, $1, params, accounts)
+      end
+
+      def retrieve_external_accounts(route, method_url, params, headers)
+        route =~ method_url
+        retrieve_object_cards(:account, $1, accounts)
+      end
+
+      def retrieve_external_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+
+        assert_existence :card, $2, get_card(account, $2)
+      end
+
+      def delete_external_account(route, method_url, params, headers)
+        route =~ method_url
+        delete_card_from(:account, $1, $2, accounts)
+      end
+
+      def update_external_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+
+        card = assert_existence :card, $2, get_card(account, $2)
+        card.merge!(params)
+        card
+      end
+
+      def verify_external_account(route, method_url, params, headers)
+        route =~ method_url
+        account = assert_existence :account, $1, accounts[$1]
+
+        external_account = assert_existence :bank_account, $2, verify_bank_account(account, $2)
+        external_account
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def verify_bank_account(object, bank_account_id, class_name='Customer')
+        bank_accounts = object[:external_accounts] || object[:bank_accounts] || object[:sources]
+        bank_account = bank_accounts[:data].find{|acc| acc[:id] == bank_account_id }
+        return if bank_account.nil?
+        bank_account['status'] = 'verified'
+        bank_account
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def get_card(object, card_id, class_name='Customer')
+        cards = object[:cards] || object[:sources] || object[:external_accounts]
+        card = cards[:data].find{|cc| cc[:id] == card_id }
+        if card.nil?
+          if class_name == 'Recipient'
+            msg = "#{class_name} #{object[:id]} does not have a card with ID #{card_id}"
+            raise Stripe::InvalidRequestError.new(msg, 'card', http_status: 404)
+          else
+            msg = "There is no source with ID #{card_id}"
+            raise Stripe::InvalidRequestError.new(msg, 'id', http_status: 404)
+          end
+        end
+        card
+      end
+
+      def add_source_to_object(type, source, object, replace_current=false)
+        source[type] = object[:id]
+        sources = object[:sources]
+
+        if replace_current && sources[:data]
+          sources[:data].delete_if {|source| source[:id] == object[:default_source]}
+          object[:default_source] = source[:id]
+          sources[:data] = [source]
+        else
+          sources[:total_count] = (sources[:total_count] || 0) + 1
+          (sources[:data] ||= []) << source
+        end
+        object[:default_source] = source[:id] if object[:default_source].nil?
+
+        source
+      end
+
+      def add_card_to_object(type, card, object, replace_current=false)
+        card[type] = object[:id]
+        cards_or_sources = object[:cards] || object[:sources] || object[:external_accounts]
+
+        is_customer = object.has_key?(:sources)
+
+        if replace_current && cards_or_sources[:data]
+          cards_or_sources[:data].delete_if {|card| card[:id] == object[:default_card]}
+          object[:default_card]   = card[:id] unless is_customer
+          object[:default_source] = card[:id] if is_customer
+          cards_or_sources[:data] = [card]
+        else
+          cards_or_sources[:total_count] = (cards_or_sources[:total_count] || 0) + 1
+          (cards_or_sources[:data] ||= []) << card
+        end
+
+        object[:default_card]   = card[:id] if !is_customer && object[:default_card].nil?
+        object[:default_source] = card[:id] if is_customer  && object[:default_source].nil?
+
+        card
+      end
+
+      def retrieve_object_cards(type, type_id, objects)
+        resource = assert_existence type, type_id, objects[type_id]
+        cards = resource[:cards] || resource[:sources] || resource[:external_accounts]
+
+        Data.mock_list_object(cards[:data])
+      end
+
+      def delete_card_from(type, type_id, card_id, objects)
+        resource = assert_existence type, type_id, objects[type_id]
+
+        assert_existence :card, card_id, get_card(resource, card_id)
+
+        card = { id: card_id, deleted: true }
+        cards_or_sources = resource[:cards] || resource[:sources] || resource[:external_accounts]
+        cards_or_sources[:data].reject!{|cc|
+          cc[:id] == card[:id]
+        }
+
+        is_customer = resource.has_key?(:sources)
+        new_default = cards_or_sources[:data].count > 0 ? cards_or_sources[:data].first[:id] : nil
+        resource[:default_card]   = new_default unless is_customer
+        resource[:sources][:total_count] = cards_or_sources[:data].count if is_customer
+        resource[:default_source] = new_default if is_customer
+        card
+      end
+
+      def add_source_to(type, type_id, params, objects)
+        resource = assert_existence type, type_id, objects[type_id]
+
+        source =
+          if params[:card]
+            card_from_params(params[:card])
+          elsif params[:bank_account]
+            get_bank_by_token(params[:bank_account])
+          else
+            begin
+              get_card_by_token(params[:source])
+            rescue Stripe::InvalidRequestError
+              get_bank_by_token(params[:source])
+            end
+          end
+        source[:metadata].merge!(params[:metadata]) if params[:metadata]
+        add_source_to_object(type, source, resource)
+      end
+
+      def add_card_to(type, type_id, params, objects)
+        resource = assert_existence type, type_id, objects[type_id]
+
+        card = card_from_params(params[:card] || params[:source] || params[:external_accounts])
+        add_card_to_object(type, card, resource)
+      end
+
+      def validate_card(card)
+        [:exp_month, :exp_year].each do |field|
+          card[field] = card[field].to_i
+        end
+        card
+      end
+
+      def card_from_params(attrs_or_token)
+        if attrs_or_token.is_a? Hash
+          attrs_or_token = generate_card_token(attrs_or_token)
+        end
+        card = get_card_by_token(attrs_or_token)
+        validate_card(card)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def add_refund_to_charge(refund, charge)
+        refunds = charge[:refunds]
+        refunds[:data] << refund
+        refunds[:total_count] = refunds[:data].count
+
+        charge[:amount_refunded] = refunds[:data].reduce(0) {|sum, r| sum + r[:amount].to_i }
+        charge[:refunded] = true
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+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
+
+        object[:discount] = Stripe::Discount.construct_from(discount_attrs)
+        object
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def add_external_account_to(type, type_id, params, objects)
+        resource = assert_existence type, type_id, objects[type_id]
+
+        source =
+          if params[:card]
+            card_from_params(params[:card])
+          elsif params[:bank_account]
+            bank_from_params(params[:bank_account])
+          else
+            begin
+              get_card_by_token(params[:external_account])
+            rescue Stripe::InvalidRequestError
+              bank_from_params(params[:external_account])
+            end
+          end
+        add_external_account_to_object(type, source, resource)
+      end
+
+      def add_external_account_to_object(type, source, object, replace_current=false)
+        source[type] = object[:id]
+        accounts = object[:external_accounts]
+
+        if replace_current && accounts[:data]
+          accounts[:data].delete_if {|source| source[:id] == object[:default_source]}
+          object[:default_source] = source[:id]
+          accounts[:data] = [source]
+        else
+          accounts[:total_count] = (accounts[:total_count] || 0) + 1
+          (accounts[:data] ||= []) << source
+        end
+        object[:default_source] = source[:id] if object[:default_source].nil?
+
+        source
+      end
+
+      def bank_from_params(attrs_or_token)
+        if attrs_or_token.is_a? Hash
+          attrs_or_token = generate_bank_token(attrs_or_token)
+        end
+        get_bank_by_token(attrs_or_token)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+module StripeMock
+  module RequestHandlers
+    module Helpers
+
+      def get_customer_subscription(customer, sub_id)
+        customer[:subscriptions][:data].find{|sub| sub[:id] == sub_id }
+      end
+
+      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 items && items.size == plans.size
+            quantity = items &&
+              items.detect { |item| item[:plan] == plan[:id] }[:quantity] || 1
+            Data.mock_subscription_item({ plan: plan, quantity: quantity })
+          else
+            Data.mock_subscription_item({ plan: plan })
+          end
+        end
+        subscription
+      end
+
+      def custom_subscription_params(plans, cus, options = {})
+        verify_trial_end(options[:trial_end]) if options[:trial_end]
+
+        plan = plans.first if plans.size == 1
+
+        now = Time.now.utc.to_i
+        created_time = options[:created] || now
+        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) })
+        keys_to_merge = /application_fee_percent|quantity|metadata|tax_percent|billing|days_until_due/
+        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"
+          end_time = options[:billing_cycle_anchor] || get_ending_time(start_time, plan)
+          params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil, billing_cycle_anchor: options[:billing_cycle_anchor]})
+        else
+          end_time = options[:trial_end] || (Time.now.utc.to_i + plan[:trial_period_days]*86400)
+          params.merge!({status: 'trialing', current_period_end: end_time, trial_start: start_time, trial_end: end_time, billing_cycle_anchor: nil})
+        end
+
+        params
+      end
+
+      def add_subscription_to_customer(cus, sub)
+        if sub[:trial_end].nil? || sub[:trial_end] == "now"
+          id = new_id('ch')
+          charges[id] = Data.mock_charge(
+            :id => id,
+            :customer => cus[:id],
+            :amount => (sub[:plan] ? sub[:plan][:amount] : total_items_amount(sub[:items][:data]))
+          )
+        end
+
+        if cus[:currency].nil?
+          cus[:currency] = sub[:items][:data][0][:plan][:currency]
+        elsif cus[:currency] != sub[:items][:data][0][:plan][:currency]
+          raise Stripe::InvalidRequestError.new( "Can't combine currencies on a single customer. This customer has had a subscription, coupon, or invoice item with currency #{cus[:currency]}", 'currency', http_status: 400)
+        end
+        cus[:subscriptions][:total_count] = (cus[:subscriptions][:total_count] || 0) + 1
+        cus[:subscriptions][:data].unshift sub
+      end
+
+      def delete_subscription_from_customer(cus, subscription)
+        cus[:subscriptions][:data].reject!{|sub|
+          sub[:id] == subscription[:id]
+        }
+        cus[:subscriptions][:total_count] -=1
+      end
+
+      # `intervals` is set to 1 when calculating current_period_end from current_period_start & plan
+      # `intervals` is set to 2 when calculating Stripe::Invoice.upcoming end from current_period_start & plan
+      def get_ending_time(start_time, plan, intervals = 1)
+        return start_time unless plan
+
+        case plan[:interval]
+        when "week"
+          start_time + (604800 * (plan[:interval_count] || 1) * intervals)
+        when "month"
+          (Time.at(start_time).to_datetime >> ((plan[:interval_count] || 1) * intervals)).to_time.to_i
+        when "year"
+          (Time.at(start_time).to_datetime >> (12 * intervals)).to_time.to_i # max period is 1 year
+        else
+          start_time
+        end
+      end
+
+      def verify_trial_end(trial_end)
+        if trial_end != "now"
+          if !trial_end.is_a? Integer
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer', nil, http_status: 400)
+          elsif trial_end < Time.now.utc.to_i
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: must be an integer Unix timestamp in the future', nil, http_status: 400)
+          elsif trial_end > Time.now.utc.to_i + 31557600*5 # five years
+            raise Stripe::InvalidRequestError.new('Invalid timestamp: can be no more than five years in the future', nil, http_status: 400)
+          end
+        end
+      end
+
+      def total_items_amount(items)
+        total = 0
+        items.each { |i| total += (i[:quantity] || 1) * i[:plan][:amount] }
+        total
+      end
+    end
+  end
+end