stripe 1.31.0 → 1.58.0

data/test/stripe/account_test.rb

@@ -52,7 +52,23 @@ module Stripe
       assert_equal 'secret-key', account.keys.secret
     end
 
-    should "be updatable" do
+    should "be rejectable" do
+      account_data = {:id => 'acct_foo'}
+      @mock.expects(:get).
+        once.
+        with('https://api.stripe.com/v1/accounts/acct_foo', nil, nil).
+        returns(make_response(account_data))
+
+      @mock.expects(:post).
+        once.
+        with("https://api.stripe.com/v1/accounts/acct_foo/reject", nil, 'reason=fraud').
+        returns(make_response(account_data))
+
+      account = Stripe::Account.retrieve('acct_foo')
+      account.reject(:reason => 'fraud')
+    end
+
+    should "be saveable" do
       resp = {
         :id => 'acct_foo',
         :legal_entity => {
@@ -77,6 +93,20 @@ module Stripe
       a.save
     end
 
+    should "be updatable" do
+      resp = {
+        :id => 'acct_foo',
+        :business_name => 'ACME Corp',
+      }
+      @mock.expects(:post).
+        once.
+        with('https://api.stripe.com/v1/accounts/acct_foo', nil, 'business_name=ACME+Corp').
+        returns(make_response(resp))
+
+      a = Stripe::Account.update('acct_foo', :business_name => "ACME Corp")
+      assert_equal('ACME Corp', a.business_name)
+    end
+
     should 'disallow direct overrides of legal_entity' do
       account = Stripe::Account.construct_from(make_account({
         :keys => {
@@ -121,7 +151,7 @@ module Stripe
         :id => 'acct_1234',
         :external_accounts => {
           :object => "list",
-          :url => "/v1/accounts/acct_1234/external_accounts",
+          :resource_url => "/v1/accounts/acct_1234/external_accounts",
           :data => [],
         }
       }
@@ -140,7 +170,7 @@ module Stripe
         :id => 'acct_1234',
         :external_accounts => {
           :object => "list",
-          :url => "/v1/accounts/acct_1234/external_accounts",
+          :resource_url => "/v1/accounts/acct_1234/external_accounts",
           :data => [{
             :id => "ba_1234",
             :object => "bank_account",
@@ -155,8 +185,8 @@ module Stripe
     should "#serialize_params an a new additional_owners" do
       obj = Stripe::Util.convert_to_stripe_object({
         :object => "account",
-        :legal_entity => {
-        },
+        :legal_entity => Stripe::StripeObject.construct_from({
+        }),
       }, {})
       obj.legal_entity.additional_owners = [
         { :first_name => "Joe" },
@@ -171,7 +201,7 @@ module Stripe
           }
         }
       }
-      assert_equal(expected, obj.class.serialize_params(obj))
+      assert_equal(expected, obj.serialize_params)
     end
 
     should "#serialize_params on an partially changed additional_owners" do
@@ -197,7 +227,7 @@ module Stripe
           }
         }
       }
-      assert_equal(expected, obj.class.serialize_params(obj))
+      assert_equal(expected, obj.serialize_params)
     end
 
     should "#serialize_params on an unchanged additional_owners" do
@@ -220,7 +250,7 @@ module Stripe
           :additional_owners => {}
         }
       }
-      assert_equal(expected, obj.class.serialize_params(obj))
+      assert_equal(expected, obj.serialize_params)
     end
 
     # Note that the empty string that we send for this one has a special
@@ -246,7 +276,23 @@ module Stripe
           :additional_owners => ""
         }
       }
-      assert_equal(expected, obj.class.serialize_params(obj))
+      assert_equal(expected, obj.serialize_params)
+    end
+
+    context "#bank_account=" do
+      should "warn that #bank_account= is deprecated" do
+        old_stderr = $stderr
+        $stderr = StringIO.new
+        begin
+          a = Stripe::Account.new("test_account")
+          a.bank_account = "tok_123"
+          message = "NOTE: Stripe::Account#bank_account= is " +
+            "deprecated; use #external_account= instead"
+          assert_match Regexp.new(message), $stderr.string
+        ensure
+          $stderr = old_stderr
+        end
+      end
     end
   end
 end

data/test/stripe/alipay_account_test.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class AlipayAccountTest < Test::Unit::TestCase
+    should "raise if accessing Stripe::Alipay.account directly" do
+      assert_raises NotImplementedError do
+        Stripe::AlipayAccount.retrieve "card_12345"
+      end
+    end
+  end
+end

data/test/stripe/api_operations_test.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class ApiOperationsTest < Test::Unit::TestCase
+    class UpdateableResource < APIResource
+      include Stripe::APIOperations::Save
+
+      def self.protected_fields
+        [:protected]
+      end
+    end
+
+    context ".update" do
+      should "post the correct parameters to the resource URL" do
+        @mock.expects(:post).once.
+          with("#{Stripe.api_base}/v1/updateableresources/id", nil, 'foo=bar').
+          returns(make_response({foo: 'bar'}))
+        resource = UpdateableResource::update("id", { foo: "bar" })
+        assert_equal('bar', resource.foo)
+      end
+
+      should "error on protected fields" do
+        e = assert_raises do
+          UpdateableResource::update("id", { protected: "bar" })
+        end
+        assert_equal "Cannot update protected field: protected", e.message
+      end
+    end
+  end
+end

data/test/stripe/api_resource_test.rb

@@ -3,6 +3,26 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ApiResourceTest < Test::Unit::TestCase
+    class NestedTestAPIResource < Stripe::APIResource
+      save_nested_resource :external_account
+    end
+
+    context ".save_nested_resource" do
+      should "can have a scalar set" do
+        r = NestedTestAPIResource.new("test_resource")
+        r.external_account = "tok_123"
+        assert_equal "tok_123", r.external_account
+      end
+
+      should "set a flag if given an object source" do
+        r = NestedTestAPIResource.new("test_resource")
+        r.external_account = {
+          :object => 'card'
+        }
+        assert_equal true, r.external_account.save_with_parent
+      end
+    end
+
     should "creating a new APIResource should not fetch over the network" do
       @mock.expects(:get).never
       Stripe::Customer.new("someid")
@@ -174,7 +194,7 @@ module Stripe
       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'
+            opts[:headers]['Authorization'] == 'Bearer sk_test_local'
           end.returns(make_response(make_charge))
 
           Stripe::Charge.create({:card => {:number => '4242424242424242'}},
@@ -193,7 +213,7 @@ module Stripe
 
         should "use the per-object credential when creating" do
           Stripe.expects(:execute_request).with do |opts|
-            opts[:headers][:authorization] == 'Bearer local'
+            opts[:headers]['Authorization'] == 'Bearer local'
           end.returns(make_response(make_charge))
 
           Stripe::Charge.create({:card => {:number => '4242424242424242'}},
@@ -203,15 +223,15 @@ module Stripe
         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'
+              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))
+            opts[:url] == "#{Stripe.api_base}/v1/charges/ch_test_charge/refunds" &&
+              opts[:headers]['Authorization'] == 'Bearer local'
+          end.returns(make_response(make_refund))
 
           ch = Stripe::Charge.retrieve('ch_test_charge', 'local')
-          ch.refund
+          ch.refunds.create
         end
       end
     end
@@ -280,6 +300,18 @@ module Stripe
         end
       end
 
+      should "a 403 should give a PermissionError with http status, body, and JSON body" do
+        response = make_response(make_missing_id_error, 403)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 403))
+        begin
+          Stripe::Customer.retrieve("foo")
+        rescue Stripe::PermissionError => e
+          assert_equal(403, 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))
@@ -387,6 +419,31 @@ module Stripe
         assert_equal false, c.livemode
       end
 
+      should "updating 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_customer))
+        c = Stripe::Customer.new
+        c.save({}, { :idempotency_key => 'bar' })
+        assert_equal false, c.livemode
+      end
+
+      should "updating should fail if api_key is overwritten with nil" do
+        c = Stripe::Customer.new
+        assert_raises TypeError do
+          c.save({}, { :api_key => nil })
+        end
+      end
+
+      should "updating should use the supplied api_key" do
+        Stripe.expects(:execute_request).with do |opts|
+          opts[:headers]['Authorization'] == 'Bearer sk_test_local'
+        end.returns(make_response(make_customer))
+        c = Stripe::Customer.new
+        c.save({}, { :api_key => 'sk_test_local' })
+        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
@@ -420,7 +477,7 @@ module Stripe
           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::Customer.retrieve("c_test_customer", {:stripe_account => 'acct_abc'})
       end
 
       should "passing in a stripe_account header should pass it through on save" do
@@ -652,10 +709,147 @@ module Stripe
           :display_name => nil,
         })
 
-        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts", nil, 'display_name=stripe').
+        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts", nil, 'display_name=stripe&metadata[key]=value').
           returns(make_response({"id" => "charge_id"}))
 
-        account.save(:display_name => 'stripe')
+        account.save(:display_name => 'stripe', :metadata => {:key => 'value' })
+      end
+    end
+
+    context "with retries" do
+      setup do
+        Stripe.stubs(:max_network_retries).returns(2)
+      end
+
+      should 'retry failed network requests if specified and raise if error persists' do
+        Stripe.expects(:sleep_time).at_least_once.returns(0)
+        @mock.expects(:post).times(3).with('https://api.stripe.com/v1/charges', nil, 'amount=50&currency=usd').
+          raises(Errno::ECONNREFUSED.new)
+
+        err = assert_raises Stripe::APIConnectionError do
+          Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
+        end
+        assert_match(/Request was retried 2 times/, err.message)
+      end
+
+      should 'retry failed network requests if specified and return successful response' do
+        Stripe.expects(:sleep_time).at_least_once.returns(0)
+        response = make_response({"id" => "myid"})
+        @mock.expects(:post).times(2).with('https://api.stripe.com/v1/charges', nil, 'amount=50&currency=usd').
+          raises(Errno::ECONNREFUSED.new).
+          then.
+          returns(response)
+
+        result = Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
+        assert_equal "myid", result.id
+      end
+
+      should 'not add an idempotency key to GET requests' do
+        SecureRandom.expects(:uuid).times(0)
+        Stripe.expects(:execute_request).with do |opts|
+          opts[:headers][:idempotency_key].nil?
+        end.returns(make_response({"id" => "myid"}))
+
+        Stripe::Charge.list
+      end
+
+      should 'ensure there is always an idempotency_key on POST requests' do
+        SecureRandom.expects(:uuid).at_least_once.returns("random_key")
+        Stripe.expects(:execute_request).with do |opts|
+          opts[:headers]['Idempotency-Key'] == "random_key"
+        end.returns(make_response({"id" => "myid"}))
+
+        Stripe::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
+      end
+
+      should 'ensure there is always an idempotency_key on DELETE requests' do
+        SecureRandom.expects(:uuid).at_least_once.returns("random_key")
+        Stripe.expects(:execute_request).with do |opts|
+          opts[:headers]['Idempotency-Key'] == "random_key"
+        end.returns(make_response({"id" => "myid"}))
+
+        c = Stripe::Customer.construct_from(make_customer)
+        c.delete
+      end
+
+      should 'not override a provided idempotency_key' do
+        # Note that this expectation looks like `:idempotency_key` instead of
+        # the header `Idempotency-Key` because it's user provided as seen
+        # below. The ones injected by the library itself look like headers
+        # (`Idempotency-Key`), but rest-client does allow this symbol
+        # formatting and will properly override the system generated one as
+        # expected.
+        Stripe.expects(:execute_request).with do |opts|
+          opts[:headers][:idempotency_key] == "provided_key"
+        end.returns(make_response({"id" => "myid"}))
+
+        Stripe::Charge.create({:amount => 50, :currency => 'usd', :card => { :number => nil }}, {:idempotency_key => 'provided_key'})
+      end
+
+    end
+
+    context ".should_retry?" do
+      setup do
+        Stripe.stubs(:max_network_retries).returns(2)
+      end
+
+      should 'retry on a low-level network error' do
+        assert Stripe.should_retry?(Errno::ECONNREFUSED.new, 0)
+      end
+
+      should 'retry on timeout' do
+        assert Stripe.should_retry?(RestClient::RequestTimeout.new, 0)
+      end
+
+      should 'retry on a conflict' do
+        assert Stripe.should_retry?(RestClient::Conflict.new, 0)
+      end
+
+      should 'not retry at maximum count' do
+        refute Stripe.should_retry?(RuntimeError.new, Stripe.max_network_retries)
+      end
+
+      should 'not retry on a certificate validation error' do
+        refute Stripe.should_retry?(RestClient::SSLCertificateNotVerified.new('message'), 0)
+      end
+    end
+
+    context ".sleep_time" do
+      should "should grow exponentially" do
+        Stripe.stubs(:rand).returns(1)
+        Stripe.stubs(:max_network_retry_delay).returns(999)
+        assert_equal(Stripe.initial_network_retry_delay, Stripe.sleep_time(1))
+        assert_equal(Stripe.initial_network_retry_delay * 2, Stripe.sleep_time(2))
+        assert_equal(Stripe.initial_network_retry_delay * 4, Stripe.sleep_time(3))
+        assert_equal(Stripe.initial_network_retry_delay * 8, Stripe.sleep_time(4))
+      end
+
+      should "enforce the max_network_retry_delay" do
+        Stripe.stubs(:rand).returns(1)
+        Stripe.stubs(:initial_network_retry_delay).returns(1)
+        Stripe.stubs(:max_network_retry_delay).returns(2)
+        assert_equal(1, Stripe.sleep_time(1))
+        assert_equal(2, Stripe.sleep_time(2))
+        assert_equal(2, Stripe.sleep_time(3))
+        assert_equal(2, Stripe.sleep_time(4))
+      end
+
+      should "add some randomness" do
+        random_value = 0.8
+        Stripe.stubs(:rand).returns(random_value)
+        Stripe.stubs(:initial_network_retry_delay).returns(1)
+        Stripe.stubs(:max_network_retry_delay).returns(8)
+
+        base_value = Stripe.initial_network_retry_delay * (0.5 * (1 + random_value))
+
+        # the initial value cannot be smaller than the base,
+        # so the randomness is ignored
+        assert_equal(Stripe.initial_network_retry_delay, Stripe.sleep_time(1))
+
+        # after the first one, the randomness is applied
+        assert_equal(base_value * 2, Stripe.sleep_time(2))
+        assert_equal(base_value * 4, Stripe.sleep_time(3))
+        assert_equal(base_value * 8, Stripe.sleep_time(4))
       end
     end
   end

data/test/stripe/apple_pay_domain_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class ApplePayDomainTest < Test::Unit::TestCase
+    should "create should return a new Apple Pay domain" do
+      @mock.expects(:post).once
+           .with('https://api.stripe.com/v1/apple_pay/domains', nil, '')
+           .returns(make_response(make_apple_pay_domain))
+      d = Stripe::ApplePayDomain.create
+      assert_equal "apwc_test_domain", d.id
+    end
+
+    should "domains should be deletable" do
+      @mock.expects(:get).once
+           .with('https://api.stripe.com/v1/apple_pay/domains/apwc_test_domain', nil, nil)
+           .returns(make_response(make_apple_pay_domain))
+      @mock.expects(:delete).once.returns(make_response(make_apple_pay_domain(:deleted => true)))
+      domain = Stripe::ApplePayDomain.retrieve('apwc_test_domain')
+      domain.delete
+      assert domain.deleted
+    end
+
+    should "domains should be listable" do
+      @mock.expects(:get).once.with('https://api.stripe.com/v1/apple_pay/domains', nil, nil)
+           .returns(make_response(make_apple_pay_domain_array))
+      domains = Stripe::ApplePayDomain.list
+      assert domains.data.kind_of?(Array)
+      assert_equal 3, domains.data.length
+      domains.each do |domain|
+        assert domain.kind_of?(Stripe::ApplePayDomain)
+      end
+    end
+  end
+end

data/test/stripe/application_fee_test.rb

@@ -12,11 +12,14 @@ module Stripe
     end
 
     should "application fees should be refundable" do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(make_response({:id => "fee_test_fee", :refunded => true}))
-      fee = Stripe::ApplicationFee.new("test_application_fee")
-      fee.refund
-      assert fee.refunded
+      fee = Stripe::ApplicationFee.construct_from(make_application_fee)
+
+      @mock.expects(:post).once.
+        with("#{Stripe.api_base}/v1/application_fees/#{fee.id}/refunds", nil, '').
+        returns(make_response(make_application_fee_refund))
+
+      refund = fee.refunds.create
+      assert refund.is_a?(Stripe::ApplicationFeeRefund)
     end
   end
 end

data/test/stripe/bitcoin_receiver_test.rb

@@ -47,14 +47,14 @@ module Stripe
     should "delete a bitcoin receiver with no customer through top-level API" do
       @mock.expects(:delete).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, nil).once.returns(make_response({:deleted => true, :id => "btcrcv_test_receiver"}))
       receiver = Stripe::BitcoinReceiver.construct_from(make_bitcoin_receiver)
-      response = receiver.delete
+      receiver.delete
       assert(receiver.deleted)
     end
 
     should "delete a bitcoin receiver with a customer through customer's subresource API" do
       @mock.expects(:delete).with("#{Stripe.api_base}/v1/customers/customer_foo/sources/btcrcv_test_receiver", nil, nil).once.returns(make_response({:deleted => true, :id => "btcrcv_test_receiver"}))
       receiver = Stripe::BitcoinReceiver.construct_from(make_bitcoin_receiver(:customer => 'customer_foo'))
-      response = receiver.delete
+      receiver.delete
       assert(receiver.deleted)
     end
   end

data/test/stripe/charge_refund_test.rb

@@ -51,5 +51,17 @@ module Stripe
       refund = charge.refunds.create(:amount => 20)
       assert_equal 'test_new_refund', refund.id
     end
+
+    should "should refund a charge with given amount" do
+      @mock.expects(:get).
+        with("#{Stripe.api_base}/v1/charges/test_charge", nil, nil).
+        twice.returns(make_response(make_charge(:id => 'test_charge')))
+      @mock.expects(:post).
+        with("#{Stripe.api_base}/v1/charges/test_charge/refunds", nil, 'amount=20').
+        once.returns(make_response(make_refund(:amount => 20)))
+
+      charge = Stripe::Charge.retrieve('test_charge')
+      charge.refund(:amount => 20)
+    end
   end
 end

data/test/stripe/charge_test.rb

@@ -12,10 +12,24 @@ module Stripe
     end
 
     should "charges should be refundable" do
+      c = Stripe::Charge.construct_from(make_charge)
       @mock.expects(:get).never
-      @mock.expects(:post).once.returns(make_response({:id => "ch_test_charge", :refunded => true}))
-      c = Stripe::Charge.new("test_charge")
-      c.refund
+      @mock.expects(:post).once.returns(make_response(make_refund(:charge => c)))
+      r = c.refunds.create
+      assert r.is_a?(Stripe::Refund)
+    end
+
+    should "charges should be refundable for old API versions" do
+      # "refunds" was a plain array in old API versions but is not a Stripe
+      # list (see the implementation of `make_charge` for a current example)
+      data = make_charge.merge!(:refunds => [])
+      c = Stripe::Charge.construct_from(data)
+      @mock.expects(:get).never
+      @mock.expects(:post).once.
+        with("#{Stripe.api_base}/v1/charges/#{c.id}/refund", nil, '').
+        returns(make_response(data.merge(:refunded => true)))
+      c = c.refund
+      assert c.is_a?(Stripe::Charge)
       assert c.refunded
     end
 
@@ -28,6 +42,14 @@ module Stripe
     end
 
     should "charges should be updateable" do
+      @mock.expects(:post).once.
+        with('https://api.stripe.com/v1/charges/test_charge', nil, 'metadata[foo]=bar').
+        returns(make_response(make_charge(metadata: {'foo' => 'bar'})))
+      c = Stripe::Charge.update("test_charge", metadata: {foo: 'bar'})
+      assert_equal('bar', c.metadata['foo'])
+    end
+
+    should "charges should be saveable" do
       @mock.expects(:get).once.returns(make_response(make_charge))
       @mock.expects(:post).once.returns(make_response(make_charge))
       c = Stripe::Charge.new("test_charge")
@@ -58,6 +80,12 @@ module Stripe
       assert c.card.kind_of?(Stripe::StripeObject) && c.card.object == 'card'
     end
 
+    should "charges should have Outcome objects associated with their outcome property" do
+      @mock.expects(:get).once.returns(make_response(make_charge))
+      c = Stripe::Charge.retrieve("test_charge")
+      assert c.outcome.kind_of?(Stripe::StripeObject) && c.outcome.type == 'authorized'
+    end
+
     should "execute should return a new, fully executed charge when passed correct `card` parameters" do
       @mock.expects(:post).with do |url, api_key, params|
         url == "#{Stripe.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
@@ -110,7 +138,7 @@ module Stripe
         :amount => 100,
         :source => 'btcrcv_test_receiver',
         :currency => "usd",
-        :level3 => [{:red => 'firstred'}, {:one => 'fish', :red => 'another'}]
+        :level3 => [{:red => 'firstred'}, {:red => 'another', :one => 'fish'}]
       })
       assert c.paid
     end

data/test/stripe/country_spec_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class CountrySpecTest < Test::Unit::TestCase
+    should "be listable" do
+      @mock.expects(:get).once.
+      returns(make_response(country_spec_array))
+      c = Stripe::CountrySpec.list
+
+      assert_equal('/v1/country_specs', c.resource_url)
+      assert_equal('list', c.object)
+      assert(c.data.kind_of?(Array))
+      assert_equal('US', c.data[0].id)
+      assert(c.data[0].kind_of?(Stripe::CountrySpec))
+    end
+
+    should "be retrievable" do
+      resp = make_country_spec
+      @mock.expects(:get).once.
+      with('https://api.stripe.com/v1/country_specs/US', nil, nil).
+      returns(make_response(resp))
+      s = Stripe::CountrySpec.retrieve('US')
+
+      assert_equal('/v1/country_specs/US', s.resource_url)
+      assert_equal('country_spec', s.object)
+      assert(s.kind_of?(Stripe::CountrySpec))
+
+      s.supported_bank_account_currencies.map{ |k,v|  assert v.kind_of?(Array) }
+      assert_equal(['US'], s.supported_bank_account_currencies['usd'])
+      assert(s.supported_payment_currencies.include?('usd'))
+      assert s.supported_payment_currencies.kind_of?(Array)
+      assert s.supported_payment_methods.kind_of?(Array)
+
+      ['individual', 'company'].map{ |type|
+        item = s.verification_fields[type]
+        assert item.minimum.include?('external_account')
+        assert item.additional.include?('legal_entity.verification.document')
+        assert item.additional.kind_of?(Array)
+        assert item.minimum.kind_of?(Array)
+      }
+    end
+  end
+end

data/test/stripe/coupon_test.rb

@@ -8,7 +8,7 @@ module Stripe
       assert_equal "co_test_coupon", c.id
     end
 
-    should "coupons should be updateable" do
+    should "coupons should be saveable" do
       @mock.expects(:get).once.returns(make_response(make_coupon))
       @mock.expects(:post).once.returns(make_response(make_coupon))
       c = Stripe::Coupon.new("test_coupon")
@@ -16,5 +16,13 @@ module Stripe
       c.metadata['foo'] = 'bar'
       c.save
     end
+
+    should "coupons should be updateable" do
+      @mock.expects(:post).once.
+        with("https://api.stripe.com/v1/coupons/test_coupon", nil, "metadata[foo]=bar").
+        returns(make_response(make_coupon(metadata: {foo: 'bar'})))
+      c = Stripe::Coupon.update("test_coupon", metadata: {foo: 'bar'})
+      assert_equal('bar', c.metadata['foo'])
+    end
   end
 end