stripe-ruby-mock 2.5.3 → 2.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e81f8b287a3ea9c2c80e4376f24a61e93dc7c0e
-  data.tar.gz: b8da1c4bfe60eacb520828cf2ea86341bff536ac
+  metadata.gz: 771c4e4adbc92b37176d94b8f91fb1f2bef740ba
+  data.tar.gz: 86c21735586588ea3aabc958d3eb93dda6dbc7ec
 SHA512:
-  metadata.gz: 5a8fc8faa377c537d8c67893b1d71b65ed21e241827e4a391ca73fbc46333a66e6fb7bfb011e9f83a47d7019f6a75bdc738c04e42dc7e78a5b3ef7d1d46349e2
-  data.tar.gz: 028228088b4f8848c7fadae70fdcaf10a939975e08cad0b2efb45547f172ad0e79c7b79a7ff8d56687d41fba09311812c1240a9dffdebb6d0073e1a09872ff72
+  metadata.gz: 0c747fed9cf7824d59fdb1be3ec1b399beabd69d54d08101c1c46d96792fe400e4d7b8c1aa6a816c981d58d902a3fdf46c6edff21bd280a07615799384a4a82f
+  data.tar.gz: 68b2ab17e0f504f783bd8c5a20893ec89bee491a29cac16a824d8cdb45e48f7a2a34e307b153feb7fe58662ee661d2732c4d838391cf23497ea20fe0a90393a5

data/README.md

@@ -12,7 +12,7 @@ This gem has unexpectedly grown in popularity and I've gotten pretty busy, so I'
 
 In your gemfile:
 
-    gem 'stripe-ruby-mock', '~> 2.5.3', :require => 'stripe_mock'
+    gem 'stripe-ruby-mock', '~> 2.5.4', :require => 'stripe_mock'
 
 ## Features
 
@@ -68,7 +68,7 @@ describe MyApp do
     # Specify :source in place of :card (with same value) to return customer with source data
     customer = Stripe::Customer.create({
       email: 'johnny@appleseed.com',
-      card: stripe_helper.generate_card_token
+      source: stripe_helper.generate_card_token
     })
     expect(customer.email).to eq('johnny@appleseed.com')
   end
@@ -170,6 +170,7 @@ StripeMock.prepare_card_error(:incorrect_cvc)
 StripeMock.prepare_card_error(:card_declined)
 StripeMock.prepare_card_error(:missing)
 StripeMock.prepare_card_error(:processing_error)
+StripeMock.prepare_card_error(:incorrect_zip)
 ```
 
 You can see the details of each error in [lib/stripe_mock/api/errors.rb](lib/stripe_mock/api/errors.rb)

data/lib/stripe_mock.rb

@@ -1,6 +1,7 @@
 require 'ostruct'
 require 'multi_json'
 require 'dante'
+require 'time'
 
 require 'stripe'
 
@@ -37,6 +38,7 @@ require 'stripe_mock/api/test_helpers'
 require 'stripe_mock/api/webhooks'
 
 require 'stripe_mock/request_handlers/helpers/bank_account_helpers.rb'
+require 'stripe_mock/request_handlers/helpers/external_account_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/card_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/charge_helpers.rb'
 require 'stripe_mock/request_handlers/helpers/coupon_helpers.rb'
@@ -46,6 +48,7 @@ require 'stripe_mock/request_handlers/helpers/token_helpers.rb'
 require 'stripe_mock/request_handlers/validators/param_validators.rb'
 
 require 'stripe_mock/request_handlers/accounts.rb'
+require 'stripe_mock/request_handlers/external_accounts.rb'
 require 'stripe_mock/request_handlers/balance.rb'
 require 'stripe_mock/request_handlers/balance_transactions.rb'
 require 'stripe_mock/request_handlers/charges.rb'
@@ -74,11 +77,13 @@ require 'stripe_mock/test_strategies/live.rb'
 
 module StripeMock
 
+  @default_currency = 'usd'
   lib_dir = File.expand_path(File.dirname(__FILE__), '../..')
   @webhook_fixture_path = './spec/fixtures/stripe_webhooks/'
   @webhook_fixture_fallback_path = File.join(lib_dir, 'stripe_mock/webhook_fixtures')
 
   class << self
+    attr_accessor :default_currency
     attr_accessor :webhook_fixture_path
   end
 end

data/lib/stripe_mock/data.rb

@@ -3,7 +3,7 @@ module StripeMock
 
     def self.mock_account(params = {})
       id = params[:id] || 'acct_103ED82ePvKYlo2C'
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: id,
         email: "bob@example.com",
@@ -103,7 +103,7 @@ module StripeMock
 
     def self.mock_customer(sources, params)
       cus_id = params[:id] || "test_cus_default"
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       sources.each {|source| source[:customer] = cus_id}
       {
         email: 'stripe_mock@example.com',
@@ -134,7 +134,7 @@ module StripeMock
 
     def self.mock_charge(params={})
       charge_id = params[:id] || "ch_1fD6uiR9FAA2zc"
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: charge_id,
         object: "charge",
@@ -196,7 +196,7 @@ module StripeMock
     end
 
     def self.mock_refund(params={})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: "re_4fWhgUh5si7InF",
         amount: 1,
@@ -248,7 +248,7 @@ module StripeMock
     end
 
     def self.mock_bank_account(params={})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: "test_ba_default",
         object: "bank_account",
@@ -306,7 +306,7 @@ module StripeMock
             plan: {
               amount: 999,
               created: 1504035972,
-              currency: 'usd'
+              currency: StripeMock.default_currency
             },
             quantity: 1
           }]
@@ -328,7 +328,7 @@ module StripeMock
 
     def self.mock_invoice(lines, params={})
       in_id = params[:id] || "test_in_default"
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       lines << Data.mock_line_item() if lines.empty?
       invoice = {
         id: 'in_test_invoice',
@@ -379,7 +379,7 @@ module StripeMock
     end
 
     def self.mock_line_item(params = {})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: "ii_test",
         object: "line_item",
@@ -402,7 +402,7 @@ module StripeMock
     end
 
     def self.mock_invoice_item(params = {})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: "test_ii",
         object: "invoiceitem",
@@ -490,7 +490,7 @@ module StripeMock
     end
 
     def self.mock_plan(params={})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       {
         id: "2",
         object: "plan",
@@ -591,7 +591,7 @@ module StripeMock
     end
 
     def self.mock_transfer(params={})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       id = params[:id] || 'tr_test_transfer'
       {
         :status => 'pending',
@@ -623,7 +623,7 @@ module StripeMock
     end
 
     def self.mock_payout(params={})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       id = params[:id] || 'po_test_payout'
       {
         :amount => 100,
@@ -647,7 +647,7 @@ module StripeMock
 
     def self.mock_dispute(params={})
       @timestamp ||= Time.now.to_i
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       id = params[:id] || "dp_test_dispute"
       {
         :id => id,
@@ -967,7 +967,7 @@ module StripeMock
     end
 
     def self.mock_balance_transaction(params = {})
-      currency = params[:currency] || 'usd'
+      currency = params[:currency] || StripeMock.default_currency
       bt_id = params[:id] || 'test_txn_default'
       source = params[:source] || 'ch_test_charge'
       {
@@ -1015,7 +1015,7 @@ module StripeMock
           object: 'plan',
           amount: 1337,
           created: 1504716177,
-          currency: 'usd',
+          currency: StripeMock.default_currency,
           interval: 'month',
           interval_count: 1,
           livemode: false,

data/lib/stripe_mock/instance.rb

@@ -20,6 +20,7 @@ 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

data/lib/stripe_mock/request_handlers/charges.rb

@@ -41,7 +41,7 @@ module StripeMock
         end
 
         ensure_required_params(params)
-        bal_trans_params = { amount: params[:amount], source: params[:source] }
+        bal_trans_params = { amount: params[:amount], source: id }
 
         balance_transaction_id = new_balance_transaction('txn', bal_trans_params)
 

data/lib/stripe_mock/request_handlers/customers.rb

@@ -40,7 +40,7 @@ module StripeMock
           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]

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

@@ -3,7 +3,7 @@ module StripeMock
     module Helpers
 
       def verify_bank_account(object, bank_account_id, class_name='Customer')
-        bank_accounts = object[:bank_accounts] || object[:sources]
+        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'

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

@@ -3,7 +3,7 @@ module StripeMock
     module Helpers
 
       def get_card(object, card_id, class_name='Customer')
-        cards = object[:cards] || object[:sources]
+        cards = object[:cards] || object[:sources] || object[:external_accounts]
         card = cards[:data].find{|cc| cc[:id] == card_id }
         if card.nil?
           if class_name == 'Recipient'
@@ -36,7 +36,7 @@ module StripeMock
 
       def add_card_to_object(type, card, object, replace_current=false)
         card[type] = object[:id]
-        cards_or_sources = object[:cards] || object[:sources]
+        cards_or_sources = object[:cards] || object[:sources] || object[:external_accounts]
 
         is_customer = object.has_key?(:sources)
 
@@ -58,7 +58,7 @@ module StripeMock
 
       def retrieve_object_cards(type, type_id, objects)
         resource = assert_existence type, type_id, objects[type_id]
-        cards = resource[:cards] || resource[:sources]
+        cards = resource[:cards] || resource[:sources] || resource[:external_accounts]
 
         Data.mock_list_object(cards[:data])
       end
@@ -69,7 +69,7 @@ module StripeMock
         assert_existence :card, card_id, get_card(resource, card_id)
 
         card = { id: card_id, deleted: true }
-        cards_or_sources = resource[:cards] || resource[:sources]
+        cards_or_sources = resource[:cards] || resource[:sources] || resource[:external_accounts]
         cards_or_sources[:data].reject!{|cc|
           cc[:id] == card[:id]
         }
@@ -103,7 +103,7 @@ module StripeMock
       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])
+        card = card_from_params(params[:card] || params[:source] || params[:external_accounts])
         add_card_to_object(type, card, resource)
       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

@@ -6,22 +6,31 @@ module StripeMock
         customer[:subscriptions][:data].find{|sub| sub[:id] == sub_id }
       end
 
-      def custom_subscription_params(plan, cus, options = {})
+      def resolve_subscription_changes(subscription, plans, customer, options = {})
+        subscription.merge!(custom_subscription_params(plans, customer, options))
+        subscription[:items][:data] = plans.map { |plan| Data.mock_subscription_item({ plan: plan }) }
+        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 = { plan: plan, customer: cus[:id], current_period_start: start_time, created: created_time }
+        params = { customer: cus[:id], current_period_start: start_time, created: created_time }
+        params.merge!({ :plan => (plans.size == 1 ? plans.first : nil) })
         params.merge! options.select {|k,v| k =~ /application_fee_percent|quantity|metadata|tax_percent/}
         # TODO: Implement coupon logic
 
         if (((plan && plan[:trial_period_days]) || 0) == 0 && options[:trial_end].nil?) || options[:trial_end] == "now"
-          end_time = get_ending_time(start_time, plan)
-          params.merge!({status: 'active', current_period_end: end_time, trial_start: nil, trial_end: nil})
+          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})
+          params.merge!({status: 'trialing', current_period_end: end_time, trial_start: start_time, trial_end: end_time, billing_cycle_anchor: nil})
         end
 
         params
@@ -87,14 +96,6 @@ module StripeMock
         items.each { |i| total += (i[:quantity] || 1) * i[:plan][:amount] }
         total
       end
-
-      def mock_subscription_items(items = [])
-        data = []
-        items.each do |i|
-          data << Data.mock_subscription_item(i.merge(plan: plans[i[:plan].to_s]))
-        end
-        data
-      end
     end
   end
 end

data/lib/stripe_mock/request_handlers/invoices.rb

@@ -87,7 +87,7 @@ module StripeMock
           invoice_date = Time.now.to_i
           subscription_plan = assert_existence :plan, subscription_plan_id, plans[subscription_plan_id.to_s]
           preview_subscription = Data.mock_subscription
-          preview_subscription.merge!(custom_subscription_params(subscription_plan, customer, { trial_end: params[:subscription_trial_end] }))
+          preview_subscription = resolve_subscription_changes(preview_subscription, [subscription_plan], customer, { trial_end: params[:subscription_trial_end] })
           preview_subscription[:id] = subscription[:id]
           preview_subscription[:quantity] = subscription_quantity
           subscription_proration_date = params[:subscription_proration_date] || Time.now
@@ -166,9 +166,9 @@ module StripeMock
       #anonymous charge
       def invoice_charge(invoice)
         begin
-          new_charge(nil, nil, {customer: invoice[:customer]["id"], amount: invoice[:amount_due], currency: 'usd'}, nil)
+          new_charge(nil, nil, {customer: invoice[:customer]["id"], amount: invoice[:amount_due], currency: StripeMock.default_currency}, nil)
         rescue Stripe::InvalidRequestError
-          new_charge(nil, nil, {source: generate_card_token, amount: invoice[:amount_due], currency: 'usd'}, nil)
+          new_charge(nil, nil, {source: generate_card_token, amount: invoice[:amount_due], currency: StripeMock.default_currency}, nil)
         end
       end
 

data/lib/stripe_mock/request_handlers/plans.rb

@@ -11,6 +11,7 @@ module StripeMock
       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

data/lib/stripe_mock/request_handlers/subscriptions.rb

@@ -32,24 +32,10 @@ module StripeMock
         customer[:subscriptions]
       end
 
-      def plan_id_from_params(params)
-        if params[:plan]
-          params[:plan].to_s
-        elsif params[:items]
-          item = params[:items].values.find { |item| item[:plan] }
-          if item
-            item[:plan].to_s
-          end
-        end
-      end
-
       def create_customer_subscription(route, method_url, params, headers)
         route =~ method_url
 
-        plan_id = plan_id_from_params(params)
-
-        plan = assert_existence :plan, plan_id, plans[plan_id]
-
+        subscription_plans = get_subscription_plans_from_params(params)
         customer = assert_existence :customer, $1, customers[$1]
 
         if params[:source]
@@ -59,10 +45,11 @@ module StripeMock
         end
 
         subscription = Data.mock_subscription({ id: (params[:id] || new_id('su')) })
-        subscription.merge!(custom_subscription_params(plan, customer, params))
+        subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
 
         # Ensure customer has card to charge if plan has no trial and is not free
-        verify_card_present(customer, plan, subscription, params)
+        # Note: needs updating for subscriptions with multiple plans
+        verify_card_present(customer, subscription_plans.first, subscription, params)
 
         if params[:coupon]
           coupon_id = params[:coupon]
@@ -82,25 +69,23 @@ module StripeMock
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
-        clear_top_level_plan_if_multiple_items(subscription)
-
         subscriptions[subscription[:id]]
       end
 
       def create_subscription(route, method_url, params, headers)
         route =~ method_url
 
-        plan_id = plan_id_from_params(params)
-
-        plan = plan_id ? assert_existence(:plan, plan_id, plans[plan_id]) : nil
+        subscription_plans = get_subscription_plans_from_params(params)
 
         customer = params[:customer]
         customer_id = customer.is_a?(Stripe::Customer) ? customer[:id] : customer.to_s
         customer = assert_existence :customer, customer_id, customers[customer_id]
 
-        if plan && customer
-          unless customer[:currency].to_s == plan[:currency].to_s
-            raise Stripe::InvalidRequestError.new('lol', 'currency', http_status: 400)
+        if subscription_plans && customer
+          subscription_plans.each do |plan|
+            unless customer[:currency].to_s == plan[:currency].to_s
+              raise Stripe::InvalidRequestError.new("Customer's currency of #{customer[:currency]} does not match plan's currency of #{plan[:currency]}", 'currency', http_status: 400)
+            end
           end
         end
 
@@ -110,18 +95,18 @@ module StripeMock
           customer[:default_source] = new_card[:id]
         end
 
-        allowed_params = %w(customer application_fee_percent coupon items metadata plan quantity source tax_percent trial_end trial_period_days current_period_start created prorate)
+        allowed_params = %w(customer application_fee_percent coupon items metadata plan quantity source tax_percent trial_end trial_period_days current_period_start created prorate billing_cycle_anchor)
         unknown_params = params.keys - allowed_params.map(&:to_sym)
         if unknown_params.length > 0
           raise Stripe::InvalidRequestError.new("Received unknown parameter: #{unknown_params.join}", unknown_params.first.to_s, http_status: 400)
         end
 
         subscription = Data.mock_subscription({ id: (params[:id] || new_id('su')) })
-        subscription.merge!(custom_subscription_params(plan, customer, params))
-        subscription[:items][:data] = mock_subscription_items(params[:items].values) if params[:items]
+        subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
 
         # Ensure customer has card to charge if plan has no trial and is not free
-        verify_card_present(customer, plan, subscription, params)
+        # Note: needs updating for subscriptions with multiple plans
+        verify_card_present(customer, subscription_plans.first, subscription, params)
 
         if params[:coupon]
           coupon_id = params[:coupon]
@@ -141,8 +126,6 @@ module StripeMock
         subscriptions[subscription[:id]] = subscription
         add_subscription_to_customer(customer, subscription)
 
-        clear_top_level_plan_if_multiple_items(subscription)
-
         subscriptions[subscription[:id]]
       end
 
@@ -176,21 +159,12 @@ module StripeMock
           customer[:default_source] = new_card[:id]
         end
 
-        # expand the plan for addition to the customer object
-        plan_id = plan_id_from_params(params)
-
-        unless plan_id
-          plan_id = if subscription[:plan]
-                      subscription[:plan][:id]
-                    elsif subscription[:items]
-                      row = subscription[:items][:data].find { |item| item[:plan] }
-                      if row
-                        row[:plan][:id]
-                      end
-                    end
-        end
+        subscription_plans = get_subscription_plans_from_params(params)
 
-        plan = plans[plan_id]
+        # subscription plans are not being updated but load them for the response
+        if subscription_plans.empty?
+          subscription_plans = subscription[:items][:data].map { |item| item[:plan] }
+        end
 
         if params[:coupon]
           coupon_id = params[:coupon]
@@ -207,10 +181,7 @@ module StripeMock
             raise Stripe::InvalidRequestError.new("No such coupon: #{coupon_id}", 'coupon', http_status: 400)
           end
         end
-
-        assert_existence :plan, plan_id, plan
-        params[:plan] = plan if params[:plan]
-        verify_card_present(customer, plan, subscription)
+        verify_card_present(customer, subscription_plans.first, subscription)
 
         if subscription[:cancel_at_period_end]
           subscription[:cancel_at_period_end] = false
@@ -218,14 +189,12 @@ module StripeMock
         end
 
         params[:current_period_start] = subscription[:current_period_start]
-        subscription.merge!(custom_subscription_params(plan, customer, params))
+        subscription = resolve_subscription_changes(subscription, subscription_plans, customer, params)
 
         # delete the old subscription, replace with the new subscription
         customer[:subscriptions][:data].reject! { |sub| sub[:id] == subscription[:id] }
         customer[:subscriptions][:data] << subscription
 
-        clear_top_level_plan_if_multiple_items(subscription)
-
         subscription
       end
 
@@ -259,8 +228,20 @@ module StripeMock
 
       private
 
-      def clear_top_level_plan_if_multiple_items(subscription)
-        subscription[:plan] = nil if subscription[:items][:data].size > 1
+      def get_subscription_plans_from_params(params)
+        plan_ids = if params[:plan]
+                     [params[:plan].to_s]
+                   elsif params[:items]
+                     items = params[:items]
+                     items = items.values if items.respond_to?(:values)
+                     items.map { |item| item[:plan].to_s if item[:plan] }
+                   else
+                     []
+                   end
+        plan_ids.each do |plan_id|
+          assert_existence :plan, plan_id, plans[plan_id]
+        end
+        plan_ids.map { |plan_id| plans[plan_id] }
       end
 
       def verify_card_present(customer, plan, subscription, params={})

data/lib/stripe_mock/test_strategies/base.rb

@@ -3,7 +3,7 @@ module StripeMock
     class Base
 
       def create_plan_params(params={})
-        currency = params[:currency] || 'usd'
+        currency = params[:currency] || StripeMock.default_currency
         {
           :id => 'stripe_mock_default_plan_id',
           :name => 'StripeMock Default Plan ID',
@@ -23,7 +23,7 @@ module StripeMock
       end
 
       def generate_bank_token(bank_account_params={})
-        currency = bank_account_params[:currency] || 'usd'
+        currency = bank_account_params[:currency] || StripeMock.default_currency
         bank_account = {
           :country => "US",
           :currency => currency,
@@ -39,7 +39,7 @@ module StripeMock
       end
 
       def create_coupon_params(params = {})
-        currency = params[:currency] || 'usd'
+        currency = params[:currency] || StripeMock.default_currency
         {
           id: '10BUCKS',
           amount_off: 1000,

data/lib/stripe_mock/version.rb

@@ -1,4 +1,4 @@
 module StripeMock
   # stripe-ruby-mock version
-  VERSION = "2.5.3"
+  VERSION = "2.5.4"
 end

data/spec/instance_spec.rb

@@ -52,4 +52,18 @@ describe StripeMock::Instance do
     StripeMock.set_conversion_rate(1.25)
     expect(StripeMock.instance.conversion_rate).to eq(1.25)
   end
+
+  it "allows non-usd default currency" do
+    old_default_currency = StripeMock.default_currency
+    customer = begin
+      StripeMock.default_currency = "jpy"
+      Stripe::Customer.create({
+        email: 'johnny@appleseed.com',
+        source: stripe_helper.generate_card_token
+      })
+    ensure
+      StripeMock.default_currency = old_default_currency
+    end
+    expect(customer.currency).to eq("jpy")
+  end
 end

data/spec/shared_stripe_examples/bank_examples.rb

@@ -40,7 +40,7 @@ shared_examples 'Bank API' do
     expect(bank.last4).to eq("6789")
   end
 
-  it "creates a single bank with a generated bank token", :live => true do
+  it "creates a single bank with a generated bank token" do
     customer = Stripe::Customer.create
     expect(customer.sources.count).to eq 0
 

data/spec/shared_stripe_examples/charge_examples.rb

@@ -171,7 +171,7 @@ shared_examples 'Charge API' do
     bal_trans = Stripe::BalanceTransaction.retrieve(charge.balance_transaction)
     expect(bal_trans.amount).to eq(charge.amount)
     expect(bal_trans.fee).to eq(39)
-    expect(bal_trans.source).to eq(charge.source)
+    expect(bal_trans.source).to eq(charge.id)
   end
 
   context 'when conversion rate is set' do

data/spec/shared_stripe_examples/customer_examples.rb

@@ -220,8 +220,8 @@ shared_examples 'Customer API' do
   end
 
   describe 'repeating coupon with duration limit', live: true do
-    let!(:coupon) { Stripe::Coupon.create(id: '10OFF', amount_off: 1000, currency: 'usd', duration: 'repeating', duration_in_months: 12) }
-    let!(:customer) { Stripe::Customer.create(coupon: '10OFF') }
+    let!(:coupon) { stripe_helper.create_coupon(id: '10OFF', amount_off: 1000, currency: 'usd', duration: 'repeating', duration_in_months: 12) }
+    let!(:customer) { Stripe::Customer.create(coupon: coupon.id) }
     it 'creates the discount with the end date', live: true do
       discount = Stripe::Customer.retrieve(customer.id).discount
       expect(discount).to_not be_nil

data/spec/shared_stripe_examples/external_account_examples.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+shared_examples 'External Account API' do
+
+  it 'creates/returns a bank when using account.external_accounts.create given a bank token' do
+    account = Stripe::Account.create(id: 'test_account', type: 'custom', country: "US")
+    bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+    bank = account.external_accounts.create(external_account: bank_token)
+
+    expect(bank.account).to eq('test_account')
+    expect(bank.last4).to eq("1123")
+    expect(bank.exp_month).to eq(11)
+    expect(bank.exp_year).to eq(2099)
+
+    account = Stripe::Account.retrieve('test_account')
+    expect(account.external_accounts.count).to eq(1)
+    bank = account.external_accounts.first
+    expect(bank.account).to eq('test_account')
+    expect(bank.last4).to eq("1123")
+    expect(bank.exp_month).to eq(11)
+    expect(bank.exp_year).to eq(2099)
+  end
+
+  it 'creates/returns a bank when using account.external_accounts.create given bank params' do
+    account = Stripe::Account.create(id: 'test_account', type: 'custom', country: "US")
+    bank = account.external_accounts.create(external_account: {
+                                              object: 'bank_account',
+                                              account_number: '000123456789',
+                                              routing_number: '110000000',
+                                              country: 'US',
+                                              currency: 'usd'
+                                            })
+
+    expect(bank.account).to eq('test_account')
+    expect(bank.routing_number).to eq('110000000')
+    expect(bank.country).to eq('US')
+    expect(bank.currency).to eq('usd')
+
+    account = Stripe::Account.retrieve('test_account')
+    expect(account.external_accounts.count).to eq(1)
+    bank = account.external_accounts.first
+    expect(bank.account).to eq('test_account')
+    expect(bank.routing_number).to eq('110000000')
+    expect(bank.country).to eq('US')
+    expect(bank.currency).to eq('usd')
+  end
+
+  it "creates a single bank with a generated bank token" do
+    account = Stripe::Account.create(type: 'custom', country: "US")
+    expect(account.external_accounts.count).to eq 0
+
+    account.external_accounts.create external_account: stripe_helper.generate_bank_token
+    # Yes, stripe-ruby does not actually add the new bank to the account instance
+    expect(account.external_accounts.count).to eq 0
+
+    account2 = Stripe::Account.retrieve(account.id)
+    expect(account2.external_accounts.count).to eq 1
+  end
+
+  describe "retrieval and deletion with accounts" do
+    let!(:account) { Stripe::Account.create(id: 'test_account', type: 'custom', country: "US") }
+    let!(:bank_token) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:bank) { account.external_accounts.create(external_account: bank_token) }
+
+    it "can retrieve all account's banks" do
+      retrieved = account.external_accounts.all
+      expect(retrieved.count).to eq(1)
+    end
+
+    it "retrieves an account bank" do
+      retrieved = account.external_accounts.retrieve(bank.id)
+      expect(retrieved.to_s).to eq(bank.to_s)
+    end
+
+    it "retrieves an account's bank after re-fetching the account" do
+      retrieved = Stripe::Account.retrieve(account.id).external_accounts.retrieve(bank.id)
+      expect(retrieved.id).to eq bank.id
+    end
+
+    it "deletes an accounts bank" do
+      bank.delete
+      retrieved_acct = Stripe::Account.retrieve(account.id)
+      expect(retrieved_acct.external_accounts.data).to be_empty
+    end
+
+    context "deletion when the user has two external accounts" do
+      let!(:bank_token_2) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+      let!(:bank_2) { account.external_accounts.create(external_account: bank_token_2) }
+
+      it "has just one bank anymore" do
+        bank.delete
+        retrieved_acct = Stripe::Account.retrieve(account.id)
+        expect(retrieved_acct.external_accounts.data.count).to eq 1
+        expect(retrieved_acct.external_accounts.data.first.id).to eq bank_2.id
+      end
+    end
+  end
+
+  describe "Errors" do
+    it "throws an error when the account does not have the retrieving bank id" do
+      account = Stripe::Account.create(type: 'custom', country: "US")
+      bank_id = "bank_123"
+      expect { account.external_accounts.retrieve(bank_id) }.to raise_error {|e|
+        expect(e).to be_a Stripe::InvalidRequestError
+        expect(e.message).to match /no.*source/i
+        expect(e.message).to include bank_id
+        expect(e.param).to eq 'id'
+        expect(e.http_status).to eq 404
+      }
+    end
+  end
+
+  context "update bank" do
+    let!(:account) { Stripe::Account.create(id: 'test_account', type: 'custom', country: "US") }
+    let!(:bank_token) { stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099) }
+    let!(:bank) { account.external_accounts.create(external_account: bank_token) }
+
+    it "updates the bank" do
+      exp_month = 10
+      exp_year = 2098
+
+      bank.exp_month = exp_month
+      bank.exp_year = exp_year
+      bank.save
+
+      retrieved = account.external_accounts.retrieve(bank.id)
+
+      expect(retrieved.exp_month).to eq(exp_month)
+      expect(retrieved.exp_year).to eq(exp_year)
+    end
+  end
+
+  context "retrieve multiple banks" do
+
+    it "retrieves a list of multiple banks" do
+      account = Stripe::Account.create(id: 'test_account', type: 'custom', country: "US")
+
+      bank_token = stripe_helper.generate_bank_token(last4: "1123", exp_month: 11, exp_year: 2099)
+      bank1 = account.external_accounts.create(external_accout: bank_token)
+      bank_token = stripe_helper.generate_bank_token(last4: "1124", exp_month: 12, exp_year: 2098)
+      bank2 = account.external_accounts.create(external_account: bank_token)
+
+      account = Stripe::Account.retrieve('test_account')
+
+      list = account.external_accounts.all
+
+      expect(list.object).to eq("list")
+      expect(list.count).to eq(2)
+      expect(list.data.length).to eq(2)
+
+      expect(list.data.first.object).to eq("bank_account")
+      expect(list.data.first.to_hash).to eq(bank1.to_hash)
+
+      expect(list.data.last.object).to eq("bank_account")
+      expect(list.data.last.to_hash).to eq(bank2.to_hash)
+    end
+
+    it "retrieves an empty list if there's no subscriptions" do
+      Stripe::Account.create(id: 'no_banks', type: 'custom', country: "US")
+      account = Stripe::Account.retrieve('no_banks')
+
+      list = account.external_accounts.all
+
+      expect(list.object).to eq("list")
+      expect(list.count).to eq(0)
+      expect(list.data.length).to eq(0)
+    end
+  end
+
+end

data/spec/shared_stripe_examples/invoice_examples.rb

@@ -107,12 +107,12 @@ shared_examples 'Invoice API' do
   end
 
   context "retrieving upcoming invoice" do
-    let(:customer)      { @teardown_customer = true; Stripe::Customer.create(source: stripe_helper.generate_card_token) }
-    let(:coupon_amtoff) { @teardown_coupon_amtoff = true; Stripe::Coupon.create(id: '100OFF', currency: 'usd', amount_off: 100_00, duration: 'repeating', duration_in_months: 6) }
-    let(:coupon_pctoff) { @teardown_coupon_pctoff = true; Stripe::Coupon.create(id: '50%OFF', currency: 'usd', percent_off: 50, duration: 'repeating', duration_in_months: 6) }
-    let(:plan)          { @teardown_plan = true; Stripe::Plan.create(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
+    let(:customer)      { Stripe::Customer.create(source: stripe_helper.generate_card_token) }
+    let(:coupon_amtoff) { stripe_helper.create_coupon(id: '100OFF', currency: 'usd', amount_off: 100_00, duration: 'repeating', duration_in_months: 6) }
+    let(:coupon_pctoff) { stripe_helper.create_coupon(id: '50%OFF', currency: 'usd', percent_off: 50, amount_off: nil, duration: 'repeating', duration_in_months: 6) }
+    let(:plan)          { stripe_helper.create_plan(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
     let(:quantity)      { 3 }
-    let(:subscription)  { @teardown_subscription = true; Stripe::Subscription.create(plan: plan.id, customer: customer.id, quantity: quantity) }
+    let(:subscription)  { Stripe::Subscription.create(plan: plan.id, customer: customer.id, quantity: quantity) }
 
     before(with_customer:         true) { customer }
     before(with_coupon_amtoff:    true) { coupon_amtoff }
@@ -122,11 +122,11 @@ shared_examples 'Invoice API' do
     before(with_plan:             true) { plan }
     before(with_subscription:     true) { subscription }
 
-    after { subscription.delete   rescue nil if @teardown_subscription }
-    after { plan.delete           rescue nil if @teardown_plan }
-    after { coupon_pctoff.delete  rescue nil if @teardown_coupon_pctoff }
-    after { coupon_amtoff.delete  rescue nil if @teardown_coupon_amtoff }
-    after { customer.delete       rescue nil if @teardown_customer }
+    # after { subscription.delete   rescue nil if @teardown_subscription }
+    # after { plan.delete           rescue nil if @teardown_plan }
+    # after { coupon_pctoff.delete  rescue nil if @teardown_coupon_pctoff }
+    # after { coupon_amtoff.delete  rescue nil if @teardown_coupon_amtoff }
+    # after { customer.delete       rescue nil if @teardown_customer }
 
     describe 'parameter validation' do
       it 'fails without parameters' do
@@ -248,8 +248,9 @@ shared_examples 'Invoice API' do
 
       [false, true].each do |with_trial|
         describe "prorating a subscription with a new plan, with_trial: #{with_trial}" do
-          let(:new_monthly_plan) { @teardown_monthly_plan = true; Stripe::Plan.create(id: '100m', amount: 100_00, interval: 'month', name: '100m', currency: 'usd') }
-          let(:new_yearly_plan) { @teardown_yearly_plan = true; Stripe::Plan.create(id: '100y', amount: 100_00, interval: 'year', name: '100y', currency: 'usd') }
+          let(:new_monthly_plan) { stripe_helper.create_plan(id: '100m', amount: 100_00, interval: 'month', name: '100m', currency: 'usd') }
+          let(:new_yearly_plan) { stripe_helper.create_plan(id: '100y', amount: 100_00, interval: 'year', name: '100y', currency: 'usd') }
+          let(:plan) { stripe_helper.create_plan(id: '50m', amount: 50_00, interval: 'month', name: '50m', currency: 'usd') }
 
           it 'prorates while maintaining billing interval', live: true do
             # Given
@@ -341,8 +342,8 @@ shared_examples 'Invoice API' do
             expect(upcoming.lines.data[1].quantity).to eq new_quantity
           end
 
-          after { new_monthly_plan.delete rescue nil if @teardown_monthly_plan }
-          after { new_yearly_plan.delete rescue nil if @teardown_yearly_plan }
+          # after { new_monthly_plan.delete rescue nil if @teardown_monthly_plan }
+          # after { new_yearly_plan.delete rescue nil if @teardown_yearly_plan }
         end
       end
 

data/spec/shared_stripe_examples/plan_examples.rb

@@ -30,6 +30,17 @@ shared_examples 'Plan API' do
   end
 
 
+  it "creates a stripe plan without specifying ID" do
+    plan = Stripe::Plan.create(
+      :name => 'The Mock Plan',
+      :amount => 9900,
+      :currency => 'USD',
+      :interval => 1,
+    )
+
+    expect(plan.id).to match(/^test_plan/)
+  end
+
   it "stores a created stripe plan in memory" do
     plan = Stripe::Plan.create(
       :id => 'pid_2',

data/spec/shared_stripe_examples/subscription_examples.rb

@@ -283,6 +283,7 @@ shared_examples 'Customer Subscriptions' do
       expect(sub.object).to eq('subscription')
       expect(sub.plan.to_hash).to eq(plan.to_hash)
       expect(sub.trial_end - sub.trial_start).to eq(14 * 86400)
+      expect(sub.billing_cycle_anchor).to be_nil
 
       customer = Stripe::Customer.retrieve('cardless')
       expect(customer.subscriptions.data).to_not be_empty
@@ -398,6 +399,18 @@ shared_examples 'Customer Subscriptions' do
       }
     end
 
+    it 'overrides current period end when billing cycle anchor is set' do
+      plan = stripe_helper.create_plan(id: 'plan', amount: 999)
+      customer = Stripe::Customer.create(source: gen_card_tk)
+      billing_cycle_anchor = Time.now.utc.to_i + 3600
+
+      sub = Stripe::Subscription.create({ plan: 'plan', customer: customer.id, billing_cycle_anchor: billing_cycle_anchor })
+
+      expect(sub.status).to eq('active')
+      expect(sub.current_period_end).to eq(billing_cycle_anchor)
+      expect(sub.billing_cycle_anchor).to eq(billing_cycle_anchor)
+    end
+
     it 'when plan defined inside items', live: true do
       plan = stripe_helper.create_plan(id: 'BASE_PRICE_PLAN1')
 
@@ -504,6 +517,57 @@ shared_examples 'Customer Subscriptions' do
       expect(customer.subscriptions.data.first.customer).to eq(customer.id)
     end
 
+    it "updates a stripe customer's existing subscription with single plan when multiple plans inside of items" do
+      silver_plan = stripe_helper.create_plan(id: 'silver')
+      gold_plan = stripe_helper.create_plan(id: 'gold')
+      addon_plan = stripe_helper.create_plan(id: 'addon_plan')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk, plan: silver_plan.id)
+
+      sub = Stripe::Subscription.retrieve(customer.subscriptions.data.first.id)
+      sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon_plan.id, quantity: 2 }]
+      expect(sub.save).to be_truthy
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan).to be_nil
+
+      customer = Stripe::Customer.retrieve('test_customer_sub')
+      expect(customer.subscriptions.data).to_not be_empty
+      expect(customer.subscriptions.count).to eq(1)
+      expect(customer.subscriptions.data.length).to eq(1)
+
+      expect(customer.subscriptions.data.first.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.plan).to be_nil
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.items.data[0].plan.to_hash).to eq(gold_plan.to_hash)
+      expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon_plan.to_hash)
+    end
+
+    it "updates a stripe customer's existing subscription with multple plans when multiple plans inside of items" do
+      silver_plan = stripe_helper.create_plan(id: 'silver')
+      gold_plan = stripe_helper.create_plan(id: 'gold')
+      addon1_plan = stripe_helper.create_plan(id: 'addon1')
+      addon2_plan = stripe_helper.create_plan(id: 'addon2')
+      customer = Stripe::Customer.create(id: 'test_customer_sub', source: gen_card_tk)
+      sub = Stripe::Subscription.create(customer: customer.id, items: [{ plan: silver_plan.id }, { plan: addon1_plan.id }])
+
+      sub.items = [{ plan: gold_plan.id, quantity: 2 }, { plan: addon2_plan.id, quantity: 2 }]
+      expect(sub.save).to be_truthy
+
+      expect(sub.object).to eq('subscription')
+      expect(sub.plan).to be_nil
+
+      customer = Stripe::Customer.retrieve('test_customer_sub')
+      expect(customer.subscriptions.data).to_not be_empty
+      expect(customer.subscriptions.count).to eq(1)
+      expect(customer.subscriptions.data.length).to eq(1)
+
+      expect(customer.subscriptions.data.first.id).to eq(sub.id)
+      expect(customer.subscriptions.data.first.plan).to be_nil
+      expect(customer.subscriptions.data.first.customer).to eq(customer.id)
+      expect(customer.subscriptions.data.first.items.data[0].plan.to_hash).to eq(gold_plan.to_hash)
+      expect(customer.subscriptions.data.first.items.data[1].plan.to_hash).to eq(addon2_plan.to_hash)
+    end
+
     it 'when adds coupon', live: true do
       plan = stripe_helper.create_plan(id: 'plan_with_coupon2', name: 'One More Test Plan', amount: 777)
       coupon = stripe_helper.create_coupon
@@ -857,13 +921,13 @@ shared_examples 'Customer Subscriptions' do
       expect(subscription.items.object).to eq('list')
       expect(subscription.items.data.class).to eq(Array)
       expect(subscription.items.data.count).to eq(1)
-      expect(subscription.items.data.first.id).to eq('si_1AwFf62eZvKYlo2C9u6Dhf9')
-      expect(subscription.items.data.first.created).to eq(1504035973)
+      expect(subscription.items.data.first.id).to eq('test_txn_default')
+      expect(subscription.items.data.first.created).to eq(1504716183)
       expect(subscription.items.data.first.object).to eq('subscription_item')
-      expect(subscription.items.data.first.plan.amount).to eq(999)
-      expect(subscription.items.data.first.plan.created).to eq(1504035972)
+      expect(subscription.items.data.first.plan.amount).to eq(0)
+      expect(subscription.items.data.first.plan.created).to eq(1466698898)
       expect(subscription.items.data.first.plan.currency).to eq('usd')
-      expect(subscription.items.data.first.quantity).to eq(1)
+      expect(subscription.items.data.first.quantity).to eq(2)
     end
   end
 

data/spec/support/stripe_examples.rb

@@ -13,6 +13,7 @@ def it_behaves_like_stripe(&block)
   it_behaves_like 'Card API', &block
   it_behaves_like 'Charge API', &block
   it_behaves_like 'Bank API', &block
+  it_behaves_like 'External Account API', &block
   it_behaves_like 'Coupon API', &block
   it_behaves_like 'Customer API', &block
   it_behaves_like 'Dispute API', &block

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stripe-ruby-mock
 version: !ruby/object:Gem::Version
-  version: 2.5.3
+  version: 2.5.4
 platform: ruby
 authors:
 - Gilbert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-22 00:00:00.000000000 Z
+date: 2018-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: stripe
@@ -105,7 +105,6 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
-- ChangeLog.rdoc
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -146,10 +145,12 @@ files:
 - lib/stripe_mock/request_handlers/customers.rb
 - lib/stripe_mock/request_handlers/disputes.rb
 - lib/stripe_mock/request_handlers/events.rb
+- lib/stripe_mock/request_handlers/external_accounts.rb
 - lib/stripe_mock/request_handlers/helpers/bank_account_helpers.rb
 - lib/stripe_mock/request_handlers/helpers/card_helpers.rb
 - lib/stripe_mock/request_handlers/helpers/charge_helpers.rb
 - lib/stripe_mock/request_handlers/helpers/coupon_helpers.rb
+- lib/stripe_mock/request_handlers/helpers/external_account_helpers.rb
 - lib/stripe_mock/request_handlers/helpers/subscription_helpers.rb
 - lib/stripe_mock/request_handlers/helpers/token_helpers.rb
 - lib/stripe_mock/request_handlers/invoice_items.rb
@@ -238,6 +239,7 @@ files:
 - spec/shared_stripe_examples/customer_examples.rb
 - spec/shared_stripe_examples/dispute_examples.rb
 - spec/shared_stripe_examples/error_mock_examples.rb
+- spec/shared_stripe_examples/external_account_examples.rb
 - spec/shared_stripe_examples/extra_features_examples.rb
 - spec/shared_stripe_examples/invoice_examples.rb
 - spec/shared_stripe_examples/invoice_item_examples.rb
@@ -304,6 +306,7 @@ test_files:
 - spec/shared_stripe_examples/customer_examples.rb
 - spec/shared_stripe_examples/dispute_examples.rb
 - spec/shared_stripe_examples/error_mock_examples.rb
+- spec/shared_stripe_examples/external_account_examples.rb
 - spec/shared_stripe_examples/extra_features_examples.rb
 - spec/shared_stripe_examples/invoice_examples.rb
 - spec/shared_stripe_examples/invoice_item_examples.rb

data/ChangeLog.rdoc

@@ -1,4 +0,0 @@
-=== 0.1.0 / 2013-04-28
-
-* Initial release:
-