stripe 1.27.2 → 5.33.0

data/lib/stripe/dispute.rb

@@ -1,16 +0,0 @@
-module Stripe
-  class Dispute < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Update
-
-    def close(params={}, opts={})
-      response, opts = request(:post, close_url, params, opts)
-      refresh_from(response, opts)
-    end
-
-    def close_url
-      url + '/close'
-    end
-  end
-end

data/lib/stripe/errors/api_connection_error.rb

@@ -1,4 +0,0 @@
-module Stripe
-  class APIConnectionError < StripeError
-  end
-end

data/lib/stripe/errors/api_error.rb

@@ -1,4 +0,0 @@
-module Stripe
-  class APIError < StripeError
-  end
-end

data/lib/stripe/errors/authentication_error.rb

@@ -1,4 +0,0 @@
-module Stripe
-  class AuthenticationError < StripeError
-  end
-end

data/lib/stripe/errors/card_error.rb

@@ -1,12 +0,0 @@
-module Stripe
-  class CardError < StripeError
-    attr_reader :param, :code
-
-    def initialize(message, param, code, http_status=nil, http_body=nil, json_body=nil,
-                   http_headers=nil)
-      super(message, http_status, http_body, json_body, http_headers)
-      @param = param
-      @code = code
-    end
-  end
-end

data/lib/stripe/errors/invalid_request_error.rb

@@ -1,11 +0,0 @@
-module Stripe
-  class InvalidRequestError < StripeError
-    attr_accessor :param
-
-    def initialize(message, param, http_status=nil, http_body=nil, json_body=nil,
-                   http_headers=nil)
-      super(message, http_status, http_body, json_body, http_headers)
-      @param = param
-    end
-  end
-end

data/lib/stripe/errors/rate_limit_error.rb

@@ -1,4 +0,0 @@
-module Stripe
-  class RateLimitError < StripeError
-  end
-end

data/lib/stripe/errors/stripe_error.rb

@@ -1,26 +0,0 @@
-module Stripe
-  class StripeError < StandardError
-    attr_reader :message
-    attr_reader :http_status
-    attr_reader :http_body
-    attr_reader :http_headers
-    attr_reader :request_id
-    attr_reader :json_body
-
-    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil,
-                   http_headers=nil)
-      @message = message
-      @http_status = http_status
-      @http_body = http_body
-      @http_headers = http_headers || {}
-      @json_body = json_body
-      @request_id = @http_headers[:request_id]
-    end
-
-    def to_s
-      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
-      id_string = @request_id.nil? ? "" : "(Request #{@request_id}) "
-      "#{status_string}#{id_string}#{@message}"
-    end
-  end
-end

data/lib/stripe/event.rb

@@ -1,5 +0,0 @@
-module Stripe
-  class Event < APIResource
-    include Stripe::APIOperations::List
-  end
-end

data/lib/stripe/file_upload.rb

@@ -1,22 +0,0 @@
-module Stripe
-  class FileUpload < APIResource
-    def self.url
-      "/v1/files"
-    end
-
-    def self.create(params={}, opts={})
-      opts = {
-        :content_type => 'multipart/form-data',
-        :api_base => Stripe::uploads_base
-      }.merge(opts)
-      response, opts = request(:post, url, params, opts)
-      Util.convert_to_stripe_object(response, opts)
-    end
-
-    def self.all(filters={}, opts={})
-      opts = {:api_base => Stripe::uploads_base}.merge(opts)
-      response, opts = request(:get, url, filters, opts)
-      Util.convert_to_stripe_object(response, opts)
-    end
-  end
-end

data/lib/stripe/invoice.rb

@@ -1,27 +0,0 @@
-module Stripe
-  class Invoice < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Update
-    include Stripe::APIOperations::Create
-
-    def self.upcoming(params, opts={})
-      response, opts = request(:get, upcoming_url, params, opts)
-      Util.convert_to_stripe_object(response, opts)
-    end
-
-    def pay(opts={})
-      response, opts = request(:post, pay_url, {}, opts)
-      refresh_from(response, opts)
-    end
-
-    private
-
-    def self.upcoming_url
-      url + '/upcoming'
-    end
-
-    def pay_url
-      url + '/pay'
-    end
-  end
-end

data/lib/stripe/invoice_item.rb

@@ -1,8 +0,0 @@
-module Stripe
-  class InvoiceItem < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Delete
-    include Stripe::APIOperations::Update
-  end
-end

data/lib/stripe/order.rb

@@ -1,19 +0,0 @@
-module Stripe
-  class Order < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Update
-
-    def pay(params, opts={})
-      response, opts = request(:post, pay_url, params, opts)
-      refresh_from(response, opts)
-    end
-
-    private
-
-    def pay_url
-      url + "/pay"
-    end
-
-  end
-end

data/lib/stripe/plan.rb

@@ -1,8 +0,0 @@
-module Stripe
-  class Plan < APIResource
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Delete
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Update
-  end
-end

data/lib/stripe/product.rb

@@ -1,16 +0,0 @@
-module Stripe
-  class Product < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Update
-
-    # Keep APIResource#url as `api_url` to avoid letting the external URL
-    # replace the Stripe URL.
-    alias_method :api_url, :url
-
-    # Override Stripe::APIOperations::Update#save to explicitly pass URL.
-    def save
-      super(:req_url => api_url)
-    end
-  end
-end

data/lib/stripe/recipient.rb

@@ -1,12 +0,0 @@
-module Stripe
-  class Recipient < APIResource
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Delete
-    include Stripe::APIOperations::Update
-    include Stripe::APIOperations::List
-
-    def transfers
-      Transfer.all({ :recipient => id }, @api_key)
-    end
-  end
-end

data/lib/stripe/refund.rb

@@ -1,7 +0,0 @@
-module Stripe
-  class Refund < APIResource
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Update
-  end
-end

data/lib/stripe/reversal.rb

@@ -1,14 +0,0 @@
-module Stripe
-  class Reversal < APIResource
-    include Stripe::APIOperations::Update
-    include Stripe::APIOperations::List
-
-    def url
-      "#{Transfer.url}/#{CGI.escape(transfer)}/reversals/#{CGI.escape(id)}"
-    end
-
-    def self.retrieve(id, opts={})
-      raise NotImplementedError.new("Reversals cannot be retrieved without a transfer ID. Retrieve a reversal using transfer.reversals.retrieve('reversal_id')")
-    end
-  end
-end

data/lib/stripe/sku.rb

@@ -1,8 +0,0 @@
-module Stripe
-  class SKU < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Update
-
-  end
-end

data/lib/stripe/subscription.rb

@@ -1,25 +0,0 @@
-module Stripe
-  class Subscription < APIResource
-    include Stripe::APIOperations::Update
-    include Stripe::APIOperations::Delete
-
-    def url
-      "#{Customer.url}/#{CGI.escape(customer)}/subscriptions/#{CGI.escape(id)}"
-    end
-
-    def self.retrieve(id, opts=nil)
-      raise NotImplementedError.new("Subscriptions cannot be retrieved without a customer ID. Retrieve a subscription using customer.subscriptions.retrieve('subscription_id')")
-    end
-
-    def delete_discount
-      response, opts = request(:delete, discount_url)
-      refresh_from({ :discount => nil }, opts, true)
-    end
-
-    private
-
-    def discount_url
-      url + '/discount'
-    end
-  end
-end

data/lib/stripe/token.rb

@@ -1,5 +0,0 @@
-module Stripe
-  class Token < APIResource
-    include Stripe::APIOperations::Create
-  end
-end

data/lib/stripe/transfer.rb

@@ -1,17 +0,0 @@
-module Stripe
-  class Transfer < APIResource
-    include Stripe::APIOperations::List
-    include Stripe::APIOperations::Create
-    include Stripe::APIOperations::Update
-
-    def cancel
-      response, api_key = Stripe.request(:post, cancel_url, @api_key)
-      refresh_from(response, api_key)
-    end
-
-    def cancel_url
-      url + '/cancel'
-    end
-
-  end
-end

data/test/stripe/account_test.rb

@@ -1,118 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class AccountTest < Test::Unit::TestCase
-    should "be retrievable" do
-      resp = {:email => "test+bindings@stripe.com", :charge_enabled => false, :details_submitted => false}
-      @mock.expects(:get).
-        once.
-        with('https://api.stripe.com/v1/account', nil, nil).
-        returns(make_response(resp))
-      a = Stripe::Account.retrieve
-      assert_equal "test+bindings@stripe.com", a.email
-      assert !a.charge_enabled
-      assert !a.details_submitted
-    end
-
-    should "be retrievable via plural endpoint" do
-      resp = {:email => "test+bindings@stripe.com", :charge_enabled => false, :details_submitted => false}
-      @mock.expects(:get).
-        once.
-        with('https://api.stripe.com/v1/accounts/acct_foo', nil, nil).
-        returns(make_response(resp))
-      a = Stripe::Account.retrieve('acct_foo')
-      assert_equal "test+bindings@stripe.com", a.email
-      assert !a.charge_enabled
-      assert !a.details_submitted
-    end
-
-    should "be retrievable using an API key as the only argument" do
-      account = mock
-      Stripe::Account.expects(:new).once.with(nil, {:api_key => 'sk_foobar'}).returns(account)
-      account.expects(:refresh).once
-      Stripe::Account.retrieve('sk_foobar')
-    end
-
-    should "be updatable" do
-      resp = {
-        :id => 'acct_foo',
-        :legal_entity => {
-          :address => {
-            :line1 => '1 Two Three'
-          }
-        }
-      }
-      @mock.expects(:get).
-        once.
-        with('https://api.stripe.com/v1/accounts/acct_foo', nil, nil).
-        returns(make_response(resp))
-
-      @mock.expects(:post).
-        once.
-        with('https://api.stripe.com/v1/accounts/acct_foo', nil, 'legal_entity[first_name]=Bob&legal_entity[address][line1]=2%20Three%20Four').
-        returns(make_response(resp))
-
-      a = Stripe::Account.retrieve('acct_foo')
-      a.legal_entity.first_name = 'Bob'
-      a.legal_entity.address.line1 = '2 Three Four'
-      a.save
-    end
-
-    should "be able to deauthorize an account" do
-      resp = {:id => 'acct_1234', :email => "test+bindings@stripe.com", :charge_enabled => false, :details_submitted => false}
-      @mock.expects(:get).once.returns(make_response(resp))
-      a = Stripe::Account.retrieve
-
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.connect_base}/oauth/deauthorize" && api_key.nil? && CGI.parse(params) == { 'client_id' => [ 'ca_1234' ], 'stripe_user_id' => [ a.id ]}
-      end.returns(make_response({ 'stripe_user_id' => a.id }))
-      a.deauthorize('ca_1234', 'sk_test_1234')
-    end
-
-    should "reject nil api keys" do
-      assert_raise TypeError do
-        Stripe::Account.retrieve(nil)
-      end
-      assert_raise TypeError do
-        Stripe::Account.retrieve(:api_key => nil)
-      end
-    end
-
-    should "be able to create a bank account" do
-      resp = {
-        :id => 'acct_1234',
-        :external_accounts => {
-          :object => "list",
-          :url => "/v1/accounts/acct_1234/external_accounts",
-          :data => [],
-        }
-      }
-      @mock.expects(:get).once.returns(make_response(resp))
-      a = Stripe::Account.retrieve
-
-      @mock.expects(:post).
-        once.
-        with('https://api.stripe.com/v1/accounts/acct_1234/external_accounts', nil, 'external_account=btok_1234').
-        returns(make_response(resp))
-      a.external_accounts.create({:external_account => 'btok_1234'})
-    end
-
-    should "be able to retrieve a bank account" do
-      resp = {
-        :id => 'acct_1234',
-        :external_accounts => {
-          :object => "list",
-          :url => "/v1/accounts/acct_1234/external_accounts",
-          :data => [{
-            :id => "ba_1234",
-            :object => "bank_account",
-          }],
-        }
-      }
-      @mock.expects(:get).once.returns(make_response(resp))
-      a = Stripe::Account.retrieve
-      assert_equal(BankAccount, a.external_accounts.data[0].class)
-    end
-  end
-end

data/test/stripe/api_resource_test.rb

@@ -1,632 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class ApiResourceTest < Test::Unit::TestCase
-    should "creating a new APIResource should not fetch over the network" do
-      @mock.expects(:get).never
-      Stripe::Customer.new("someid")
-    end
-
-    should "creating a new APIResource from a hash should not fetch over the network" do
-      @mock.expects(:get).never
-      Stripe::Customer.construct_from({
-        :id => "somecustomer",
-        :card => {:id => "somecard", :object => "card"},
-        :object => "customer"
-      })
-    end
-
-    should "setting an attribute should not cause a network request" do
-      @mock.expects(:get).never
-      @mock.expects(:post).never
-      c = Stripe::Customer.new("test_customer");
-      c.card = {:id => "somecard", :object => "card"}
-    end
-
-    should "accessing id should not issue a fetch" do
-      @mock.expects(:get).never
-      c = Stripe::Customer.new("test_customer")
-      c.id
-    end
-
-    should "not specifying api credentials should raise an exception" do
-      Stripe.api_key = nil
-      assert_raises Stripe::AuthenticationError do
-        Stripe::Customer.new("test_customer").refresh
-      end
-    end
-
-    should "using a nil api key should raise an exception" do
-      assert_raises TypeError do
-        Stripe::Customer.all({}, nil)
-      end
-      assert_raises TypeError do
-        Stripe::Customer.all({}, { :api_key => nil })
-      end
-    end
-
-    should "specifying api credentials containing whitespace should raise an exception" do
-      Stripe.api_key = "key "
-      assert_raises Stripe::AuthenticationError do
-        Stripe::Customer.new("test_customer").refresh
-      end
-    end
-
-    should "specifying invalid api credentials should raise an exception" do
-      Stripe.api_key = "invalid"
-      response = make_response(make_invalid_api_key_error, 401)
-      assert_raises Stripe::AuthenticationError do
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Stripe::Customer.retrieve("failing_customer")
-      end
-    end
-
-    should "AuthenticationErrors should have an http status, http body, and JSON body" do
-      Stripe.api_key = "invalid"
-      response = make_response(make_invalid_api_key_error, 401)
-      begin
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
-        Stripe::Customer.retrieve("failing_customer")
-      rescue Stripe::AuthenticationError => e
-        assert_equal(401, e.http_status)
-        assert_equal(true, !!e.http_body)
-        assert_equal(true, !!e.json_body[:error][:message])
-        assert_equal(make_invalid_api_key_error[:error][:message], e.json_body[:error][:message])
-      end
-    end
-
-    should "send expand on fetch properly" do
-      @mock.expects(:get).once.
-        with("#{Stripe.api_base}/v1/charges/ch_test_charge?expand[]=customer", nil, nil).
-        returns(make_response(make_charge))
-
-      Stripe::Charge.retrieve({:id => 'ch_test_charge', :expand => [:customer]})
-    end
-
-    should "preserve expand across refreshes" do
-      @mock.expects(:get).twice.
-        with("#{Stripe.api_base}/v1/charges/ch_test_charge?expand[]=customer", nil, nil).
-        returns(make_response(make_charge))
-
-      ch = Stripe::Charge.retrieve({:id => 'ch_test_charge', :expand => [:customer]})
-      ch.refresh
-    end
-
-    should "send expand when fetching through ListObject" do
-      @mock.expects(:get).once.
-        with("#{Stripe.api_base}/v1/customers/c_test_customer", nil, nil).
-        returns(make_response(make_customer))
-
-      @mock.expects(:get).once.
-        with("#{Stripe.api_base}/v1/customers/c_test_customer/sources/cc_test_card?expand[]=customer", nil, nil).
-        returns(make_response(make_card))
-
-      customer = Stripe::Customer.retrieve('c_test_customer')
-      customer.sources.retrieve({:id => 'cc_test_card', :expand => [:customer]})
-    end
-
-    should "send stripe account as header when set" do
-      stripe_account = "acct_0000"
-      Stripe.expects(:execute_request).with do |opts|
-        opts[:headers][:stripe_account] == stripe_account
-      end.returns(make_response(make_charge))
-
-      Stripe::Charge.create({:card => {:number => '4242424242424242'}},
-                            {:stripe_account => stripe_account, :api_key => 'sk_test_local'})
-    end
-
-    should "not send stripe account as header when not set" do
-      Stripe.expects(:execute_request).with do |opts|
-        opts[:headers][:stripe_account].nil?
-      end.returns(make_response(make_charge))
-
-      Stripe::Charge.create({:card => {:number => '4242424242424242'}},
-        'sk_test_local')
-    end
-
-    should "handle error response with empty body" do
-      response = make_response('', 500)
-      @mock.expects(:post).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
-
-      e = assert_raises Stripe::APIError do
-        Stripe::Charge.create
-      end
-
-      assert_equal 'Invalid response object from API: "" (HTTP response code was 500)', e.message
-    end
-
-    should "handle error response with non-object error value" do
-      response = make_response('{"error": "foo"}', 500)
-      @mock.expects(:post).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
-
-      e = assert_raises Stripe::APIError do
-        Stripe::Charge.create
-      end
-
-      assert_equal 'Invalid response object from API: "{\"error\": \"foo\"}" (HTTP response code was 500)', e.message
-    end
-
-    should "have default open and read timeouts" do
-      assert_equal Stripe.open_timeout, 30
-      assert_equal Stripe.read_timeout, 80
-    end
-
-    should "allow configurable open and read timeouts" do
-      original_timeouts = Stripe.open_timeout, Stripe.read_timeout
-
-      begin
-        Stripe.open_timeout = 999
-        Stripe.read_timeout = 998
-
-        Stripe.expects(:execute_request).with do |opts|
-          opts[:open_timeout] == 999 && opts[:timeout] == 998
-        end.returns(make_response(make_charge))
-
-        Stripe::Charge.create({:card => {:number => '4242424242424242'}},
-          'sk_test_local')
-      ensure
-        Stripe.open_timeout, Stripe.read_timeout = original_timeouts
-      end
-    end
-
-    context "when specifying per-object credentials" do
-      context "with no global API key set" do
-        should "use the per-object credential when creating" do
-          Stripe.expects(:execute_request).with do |opts|
-            opts[:headers][:authorization] == 'Bearer sk_test_local'
-          end.returns(make_response(make_charge))
-
-          Stripe::Charge.create({:card => {:number => '4242424242424242'}},
-            'sk_test_local')
-        end
-      end
-
-      context "with a global API key set" do
-        setup do
-          Stripe.api_key = "global"
-        end
-
-        teardown do
-          Stripe.api_key = nil
-        end
-
-        should "use the per-object credential when creating" do
-          Stripe.expects(:execute_request).with do |opts|
-            opts[:headers][:authorization] == 'Bearer local'
-          end.returns(make_response(make_charge))
-
-          Stripe::Charge.create({:card => {:number => '4242424242424242'}},
-            'local')
-        end
-
-        should "use the per-object credential when retrieving and making other calls" do
-          Stripe.expects(:execute_request).with do |opts|
-            opts[:url] == "#{Stripe.api_base}/v1/charges/ch_test_charge" &&
-              opts[:headers][:authorization] == 'Bearer local'
-          end.returns(make_response(make_charge))
-          Stripe.expects(:execute_request).with do |opts|
-            opts[:url] == "#{Stripe.api_base}/v1/charges/ch_test_charge/refund" &&
-              opts[:headers][:authorization] == 'Bearer local'
-          end.returns(make_response(make_charge))
-
-          ch = Stripe::Charge.retrieve('ch_test_charge', 'local')
-          ch.refund
-        end
-      end
-    end
-
-    context "with valid credentials" do
-      should "send along the idempotency-key header" do
-        Stripe.expects(:execute_request).with do |opts|
-          opts[:headers][:idempotency_key] == 'bar'
-        end.returns(make_response(make_charge))
-
-        Stripe::Charge.create({:card => {:number => '4242424242424242'}}, {
-          :idempotency_key => 'bar',
-          :api_key => 'local',
-        })
-      end
-
-      should "urlencode values in GET params" do
-        response = make_response(make_charge_array)
-        @mock.expects(:get).with("#{Stripe.api_base}/v1/charges?customer=test%20customer", nil, nil).returns(response)
-        charges = Stripe::Charge.all(:customer => 'test customer').data
-        assert charges.kind_of? Array
-      end
-
-      should "construct URL properly with base query parameters" do
-        response = make_response(make_invoice_customer_array)
-        @mock.expects(:get).with("#{Stripe.api_base}/v1/invoices?customer=test_customer", nil, nil).returns(response)
-        invoices = Stripe::Invoice.all(:customer => 'test_customer')
-
-        @mock.expects(:get).with("#{Stripe.api_base}/v1/invoices?customer=test_customer&paid=true", nil, nil).returns(response)
-        invoices.all(:paid => true)
-      end
-
-      should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
-        response = make_response(make_missing_id_error, 400)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Stripe::Customer.retrieve("foo")
-        rescue Stripe::InvalidRequestError => e
-          assert_equal(400, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
-        response = make_response(make_missing_id_error, 401)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Stripe::Customer.retrieve("foo")
-        rescue Stripe::AuthenticationError => e
-          assert_equal(401, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 402 should give a CardError with http status, body, and JSON body" do
-        response = make_response(make_missing_id_error, 402)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Stripe::Customer.retrieve("foo")
-        rescue Stripe::CardError => e
-          assert_equal(402, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
-        response = make_response(make_missing_id_error, 404)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-        begin
-          Stripe::Customer.retrieve("foo")
-        rescue Stripe::InvalidRequestError => e
-          assert_equal(404, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "a 429 should give a RateLimitError with http status, body, and JSON body" do
-        response = make_response(make_rate_limit_error, 429)
-        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 429))
-        begin
-          Stripe::Customer.retrieve("foo")
-        rescue Stripe::RateLimitError => e
-          assert_equal(429, e.http_status)
-          assert_equal(true, !!e.http_body)
-          assert_equal(true, e.json_body.kind_of?(Hash))
-        end
-      end
-
-      should "setting a nil value for a param should exclude that param from the request" do
-        @mock.expects(:get).with do |url, api_key, params|
-          uri = URI(url)
-          query = CGI.parse(uri.query)
-          (url =~ %r{^#{Stripe.api_base}/v1/charges?} &&
-           query.keys.sort == ['offset', 'sad'])
-        end.returns(make_response({ :count => 1, :data => [make_charge] }))
-        Stripe::Charge.all(:count => nil, :offset => 5, :sad => false)
-
-        @mock.expects(:post).with do |url, api_key, params|
-          url == "#{Stripe.api_base}/v1/charges" &&
-            api_key.nil? &&
-            CGI.parse(params) == { 'amount' => ['50'], 'currency' => ['usd'] }
-        end.returns(make_response({ :count => 1, :data => [make_charge] }))
-        Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
-      end
-
-      should "requesting with a unicode ID should result in a request" do
-        response = make_response(make_missing_id_error, 404)
-        @mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
-        c = Stripe::Customer.new("☃")
-        assert_raises(Stripe::InvalidRequestError) { c.refresh }
-      end
-
-      should "requesting with no ID should result in an InvalidRequestError with no request" do
-        c = Stripe::Customer.new
-        assert_raises(Stripe::InvalidRequestError) { c.refresh }
-      end
-
-      should "making a GET request with parameters should have a query string and no body" do
-        params = { :limit => 1 }
-        @mock.expects(:get).once.with("#{Stripe.api_base}/v1/charges?limit=1", nil, nil).returns(make_response([make_charge]))
-        Stripe::Charge.all(params)
-      end
-
-      should "making a POST request with parameters should have a body and no query string" do
-        params = { :amount => 100, :currency => 'usd', :card => 'sc_token' }
-        @mock.expects(:post).once.with do |url, get, post|
-          get.nil? && CGI.parse(post) == {'amount' => ['100'], 'currency' => ['usd'], 'card' => ['sc_token']}
-        end.returns(make_response(make_charge))
-        Stripe::Charge.create(params)
-      end
-
-      should "loading an object should issue a GET request" do
-        @mock.expects(:get).once.returns(make_response(make_customer))
-        c = Stripe::Customer.new("test_customer")
-        c.refresh
-      end
-
-      should "using array accessors should be the same as the method interface" do
-        @mock.expects(:get).once.returns(make_response(make_customer))
-        c = Stripe::Customer.new("test_customer")
-        c.refresh
-        assert_equal c.created, c[:created]
-        assert_equal c.created, c['created']
-        c['created'] = 12345
-        assert_equal c.created, 12345
-      end
-
-      should "accessing a property other than id or parent on an unfetched object should fetch it" do
-        @mock.expects(:get).once.returns(make_response(make_customer))
-        c = Stripe::Customer.new("test_customer")
-        c.charges
-      end
-
-      should "updating an object should issue a POST request with only the changed properties" do
-        @mock.expects(:post).with do |url, api_key, params|
-          url == "#{Stripe.api_base}/v1/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
-        end.once.returns(make_response(make_customer))
-        c = Stripe::Customer.construct_from(make_customer)
-        c.description = "another_mn"
-        c.save
-      end
-
-      should "updating should merge in returned properties" do
-        @mock.expects(:post).once.returns(make_response(make_customer))
-        c = Stripe::Customer.new("c_test_customer")
-        c.description = "another_mn"
-        c.save
-        assert_equal false, c.livemode
-      end
-
-      should "deleting should send no props and result in an object that has no props other deleted" do
-        @mock.expects(:get).never
-        @mock.expects(:post).never
-        @mock.expects(:delete).with("#{Stripe.api_base}/v1/customers/c_test_customer", nil, nil).once.returns(make_response({ "id" => "test_customer", "deleted" => true }))
-        c = Stripe::Customer.construct_from(make_customer)
-        c.delete
-        assert_equal true, c.deleted
-
-        assert_raises NoMethodError do
-          c.livemode
-        end
-      end
-
-      should "loading an object with properties that have specific types should instantiate those classes" do
-        @mock.expects(:get).once.returns(make_response(make_charge))
-        c = Stripe::Charge.retrieve("test_charge")
-        assert c.card.kind_of?(Stripe::StripeObject) && c.card.object == 'card'
-      end
-
-      should "loading all of an APIResource should return an array of recursively instantiated objects" do
-        @mock.expects(:get).once.returns(make_response(make_charge_array))
-        c = Stripe::Charge.all.data
-        assert c.kind_of? Array
-        assert c[0].kind_of? Stripe::Charge
-        assert c[0].card.kind_of?(Stripe::StripeObject) && c[0].card.object == 'card'
-      end
-
-      should "passing in a stripe_account header should pass it through on call" do
-        Stripe.expects(:execute_request).with do |opts|
-          opts[:method] == :get &&
-          opts[:url] == "#{Stripe.api_base}/v1/customers/c_test_customer" &&
-          opts[:headers][:stripe_account] == 'acct_abc'
-        end.once.returns(make_response(make_customer))
-        c = Stripe::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
-      end
-
-      should "passing in a stripe_account header should pass it through on save" do
-        Stripe.expects(:execute_request).with do |opts|
-          opts[:method] == :get &&
-          opts[:url] == "#{Stripe.api_base}/v1/customers/c_test_customer" &&
-          opts[:headers][:stripe_account] == 'acct_abc'
-        end.once.returns(make_response(make_customer))
-        c = Stripe::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
-
-        Stripe.expects(:execute_request).with do |opts|
-          opts[:method] == :post &&
-          opts[:url] == "#{Stripe.api_base}/v1/customers/c_test_customer" &&
-          opts[:headers][:stripe_account] == 'acct_abc' &&
-          opts[:payload] == 'description=FOO'
-        end.once.returns(make_response(make_customer))
-        c.description = 'FOO'
-        c.save
-      end
-
-      context "error checking" do
-
-        should "404s should raise an InvalidRequestError" do
-          response = make_response(make_missing_id_error, 404)
-          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
-
-          rescued = false
-          begin
-            Stripe::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Stripe::InvalidRequestError => e # we don't use assert_raises because we want to examine e
-            rescued = true
-            assert e.kind_of? Stripe::InvalidRequestError
-            assert_equal "id", e.param
-            assert_equal "Missing id", e.message
-          end
-
-          assert_equal true, rescued
-        end
-
-        should "5XXs should raise an APIError" do
-          response = make_response(make_api_error, 500)
-          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
-
-          rescued = false
-          begin
-            Stripe::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Stripe::APIError => e # we don't use assert_raises because we want to examine e
-            rescued = true
-            assert e.kind_of? Stripe::APIError
-          end
-
-          assert_equal true, rescued
-        end
-
-        should "402s should raise a CardError" do
-          response = make_response(make_invalid_exp_year_error, 402)
-          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 402))
-
-          rescued = false
-          begin
-            Stripe::Customer.new("test_customer").refresh
-            assert false #shouldn't get here either
-          rescue Stripe::CardError => e # we don't use assert_raises because we want to examine e
-            rescued = true
-            assert e.kind_of? Stripe::CardError
-            assert_equal "invalid_expiry_year", e.code
-            assert_equal "exp_year", e.param
-            assert_equal "Your card's expiration year is invalid", e.message
-          end
-
-          assert_equal true, rescued
-        end
-      end
-
-      should 'add key to nested objects' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :size => 'l',
-            :score => 4,
-            :height => 10
-          }
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[first_name]=Bob').returns(make_response({"id" => "myid"}))
-
-        acct.legal_entity.first_name = 'Bob'
-        acct.save
-      end
-
-      should 'save nothing if nothing changes' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :metadata => {
-            :key => 'value'
-          }
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, '').returns(make_response({"id" => "myid"}))
-
-        acct.save
-      end
-
-      should 'not save nested API resources' do
-        ch = Stripe::Charge.construct_from({
-          :id => 'charge_id',
-          :customer => {
-            :object => 'customer',
-            :id => 'customer_id'
-          }
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/charges/charge_id", nil, '').returns(make_response({"id" => "charge_id"}))
-
-        ch.customer.description = 'Bob'
-        ch.save
-      end
-
-      should 'correctly handle replaced nested objects' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :last_name => 'Smith',
-          }
-        })
-
-        @mock.expects(:post).once.with(
-          "#{Stripe.api_base}/v1/accounts/myid",
-          nil,
-          any_of(
-            'legal_entity[first_name]=Bob&legal_entity[last_name]=',
-            'legal_entity[last_name]=&legal_entity[first_name]=Bob'
-          )
-        ).returns(make_response({"id" => "myid"}))
-
-        acct.legal_entity = {:first_name => 'Bob'}
-        acct.save
-      end
-
-      should 'correctly handle array setting' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {}
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[additional_owners][0][first_name]=Bob').returns(make_response({"id" => "myid"}))
-
-        acct.legal_entity.additional_owners = [{:first_name => 'Bob'}]
-        acct.save
-      end
-
-      should 'correctly handle array insertion' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :additional_owners => []
-          }
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[additional_owners][0][first_name]=Bob').returns(make_response({"id" => "myid"}))
-
-        acct.legal_entity.additional_owners << {:first_name => 'Bob'}
-        acct.save
-      end
-
-      should 'correctly handle array updates' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :additional_owners => [{:first_name => 'Bob'}, {:first_name => 'Jane'}]
-          }
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, 'legal_entity[additional_owners][1][first_name]=Janet').returns(make_response({"id" => "myid"}))
-
-        acct.legal_entity.additional_owners[1].first_name = 'Janet'
-        acct.save
-      end
-
-      should 'correctly handle array noops' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :additional_owners => [{:first_name => 'Bob'}]
-          },
-          :currencies_supported => ['usd', 'cad']
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, '').returns(make_response({"id" => "myid"}))
-
-        acct.save
-      end
-
-      should 'correctly handle hash noops' do
-        acct = Stripe::Account.construct_from({
-          :id => 'myid',
-          :legal_entity => {
-            :address => {:line1 => '1 Two Three'}
-          }
-        })
-
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts/myid", nil, '').returns(make_response({"id" => "myid"}))
-
-        acct.save
-      end
-    end
-  end
-end