stripe-ruby-mock 2.3.1 → 2.5.8

data/lib/stripe_mock/instance.rb

@@ -20,12 +20,15 @@ module StripeMock
       @@handlers.find {|h| method_url =~ h[:route] }
     end
 
+    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
@@ -34,19 +37,26 @@ module StripeMock
     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_transactions, :bank_tokens, :charges, :coupons, :customers,
+    attr_reader :accounts, :balance, :balance_transactions, :bank_tokens, :charges, :coupons, :customers,
                 :disputes, :events, :invoices, :invoice_items, :orders, :plans, :recipients,
-                :transfers, :subscriptions
+                :refunds, :transfers, :payouts, :subscriptions, :country_spec, :subscriptions_items,
+                :products, :tax_rates
 
-    attr_accessor :error_queue, :debug
+    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 = {}
@@ -59,20 +69,29 @@ module StripeMock
       @invoice_items = {}
       @orders = {}
       @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, params={}, headers={}, api_base_url=nil)
+    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)
@@ -95,7 +114,7 @@ module StripeMock
         else
           res = self.send(handler[:name], handler[:route], method_url, params, headers)
           puts "           [res]  #{res}" if @debug == true
-          [res, api_key]
+          [to_faraday_hash(res), api_key]
         end
       else
         puts "[StripeMock] Warning : Unrecognized endpoint + method : [#{method} #{url}]"
@@ -109,12 +128,44 @@ module StripeMock
       @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, 404)
+        raise Stripe::InvalidRequestError.new(msg, type.to_s, http_status: 404)
       end
       obj
     end
@@ -124,14 +175,59 @@ module StripeMock
       "#{StripeMock.global_id_prefix}#{prefix}_#{@id_counter += 1}"
     end
 
-    def new_balance_transaction(prefix)
+    def new_balance_transaction(prefix, params = {})
       # balance transaction ids must be strings
-      "#{StripeMock.global_id_prefix}#{prefix}_#{@balance_transaction_counter += 1}"
+      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

@@ -1,6 +1,7 @@
 module StripeMock
   module RequestHandlers
     module Accounts
+      VALID_START_YEAR = 2009
 
       def Accounts.included(klass)
         klass.add_handler 'post /v1/accounts',      :new_account
@@ -8,6 +9,7 @@ module StripeMock
         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)
@@ -25,8 +27,14 @@ module StripeMock
 
       def update_account(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :account, $1, accounts[$1]
-        accounts[$1].merge!(params)
+        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)
@@ -34,6 +42,12 @@ module StripeMock
         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
@@ -42,6 +56,31 @@ module StripeMock
           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

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

@@ -9,11 +9,27 @@ module StripeMock
 
       def get_balance_transaction(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :balance_transaction, $1, balance_transactions[$1]
+        assert_existence :balance_transaction, $1, hide_additional_attributes(balance_transactions[$1])
       end
 
       def list_balance_transactions(route, method_url, params, headers)
-        Data.mock_list_object(balance_transactions.values, params)
+        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

data/lib/stripe_mock/request_handlers/charges.rb

@@ -8,14 +8,17 @@ module StripeMock
         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',  :create_refund
+        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 params[:idempotency_key] && charges.any?
-          original_charge = charges.values.find { |c| c[:idempotency_key] == params[:idempotency_key]}
-          return charges[original_charge[:id]] if original_charge
+        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')
@@ -28,10 +31,10 @@ module StripeMock
             if params[:customer]
               params[:source] = get_card(customers[params[:customer]], params[:source])
             else
-              params[:source] = get_card_by_token(params[:source])
+              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', 400)
+            raise Stripe::InvalidRequestError.new("Invalid token id: #{params[:source]}", 'card', http_status: 400)
           end
         elsif params[:customer]
           customer = customers[params[:customer]]
@@ -41,8 +44,21 @@ module StripeMock
         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
 
-        charges[id] = Data.mock_charge(params.merge :id => id, :balance_transaction => new_balance_transaction('txn'))
+        charge
       end
 
       def update_charge(route, method_url, params, headers)
@@ -53,7 +69,7 @@ module StripeMock
         allowed = allowed_params(params)
         disallowed = params.keys - allowed
         if disallowed.count > 0
-          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', 400)
+          raise Stripe::InvalidRequestError.new("Received unknown parameters: #{disallowed.join(', ')}" , '', http_status: 400)
         end
 
         charges[id] = Util.rmerge(charge, params)
@@ -74,7 +90,16 @@ module StripeMock
 
       def get_charge(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :charge, $1, charges[$1]
+        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)
@@ -101,24 +126,12 @@ module StripeMock
       def refund_charge(route, method_url, params, headers)
         charge = get_charge(route, method_url, params, headers)
 
-        refund = Data.mock_refund params.merge(
-          :balance_transaction => new_balance_transaction('txn'),
-          :id => new_id('re')
+        new_refund(
+          route,
+          method_url,
+          params.merge(:charge => charge[:id]),
+          headers
         )
-        add_refund_to_charge(refund, charge)
-        charge
-      end
-
-      def create_refund(route, method_url, params, headers)
-        charge = get_charge(route, method_url, params, headers)
-
-        refund = Data.mock_refund params.merge(
-          :balance_transaction => new_balance_transaction('txn'),
-          :id => new_id('re'),
-          :charge => charge[:id]
-        )
-        add_refund_to_charge(refund, charge)
-        refund
       end
 
       private
@@ -129,9 +142,11 @@ module StripeMock
         elsif params[:currency].nil?
           require_param(:currency)
         elsif non_integer_charge_amount?(params)
-          raise Stripe::InvalidRequestError.new("Invalid integer: #{params[:amount]}", 'amount', 400)
+          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', 400)
+          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
 
@@ -143,12 +158,8 @@ module StripeMock
         params[:amount] && params[:amount] < 1
       end
 
-      def require_param(param)
-        raise Stripe::InvalidRequestError.new("Missing required param: #{param}", param.to_s, 400)
-      end
-
       def allowed_params(params)
-        allowed = [:description, :metadata, :receipt_email, :fraud_details, :shipping]
+        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.

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

@@ -11,18 +11,19 @@ module StripeMock
 
       def new_coupon(route, method_url, params, headers)
         params[:id] ||= new_id('coupon')
-        raise Stripe::InvalidRequestError.new('Missing required param: duration', 'coupon', 400) unless params[:duration]
-        coupons[ params[:id] ] = Data.mock_coupon(params)
+        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 :id, $1, coupons[$1]
+        assert_existence :coupon, $1, coupons[$1]
       end
 
       def delete_coupon(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :id, $1, coupons.delete($1)
+        assert_existence :coupon, $1, coupons.delete($1)
       end
 
       def list_coupons(route, method_url, params, headers)

data/lib/stripe_mock/request_handlers/customers.rb

@@ -4,10 +4,11 @@ module StripeMock
 
       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 '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)
@@ -18,7 +19,7 @@ module StripeMock
           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, 400)
+                raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
               end
               card_from_params(params[:source])
             else
@@ -35,22 +36,22 @@ module StripeMock
           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, 400)
+            raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
           end
 
           subscription = Data.mock_subscription({ id: new_id('su') })
-          subscription.merge!(custom_subscription_params(plan, customers[ params[:id] ], params))
+          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, 400)
+          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_customer(customers[params[:id]], coupon)
+          add_coupon_to_object(customers[params[:id]], coupon)
         end
 
         customers[ params[:id] ]
@@ -77,7 +78,7 @@ module StripeMock
             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, 400)
+              raise Stripe::InvalidRequestError.new('You must supply a valid card', nil, http_status: 400)
             end
             new_card = card_from_params(params.delete(:source))
           end
@@ -89,7 +90,7 @@ module StripeMock
           coupon = coupons[ params[:coupon] ]
           assert_existence :coupon, params[:coupon], coupon
 
-          add_coupon_to_customer(cus, coupon)
+          add_coupon_to_object(cus, coupon)
         end
 
         cus
@@ -107,13 +108,30 @@ module StripeMock
 
       def get_customer(route, method_url, params, headers)
         route =~ method_url
-        assert_existence :customer, $1, customers[$1]
+        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

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/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