stripe 1.30.3 → 2.0.0

data/test/stripe/apple_pay_domain_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class ApplePayDomainTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:apple_pay_domain)
+
+    should "be listable" do
+      domains = Stripe::ApplePayDomain.list
+      assert_requested :get, "#{Stripe.api_base}/v1/apple_pay/domains"
+      assert domains.data.kind_of?(Array)
+      assert domains.data[0].kind_of?(Stripe::ApplePayDomain)
+    end
+
+    should "be retrievable" do
+      domain = Stripe::ApplePayDomain.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/apple_pay/domains/#{FIXTURE[:id]}"
+      assert domain.kind_of?(Stripe::ApplePayDomain)
+    end
+
+    should "be creatable" do
+      domain = Stripe::ApplePayDomain.create(:domain_name => "example.com")
+      assert_requested :post, "#{Stripe.api_base}/v1/apple_pay/domains"
+      assert domain.kind_of?(Stripe::ApplePayDomain)
+    end
+
+    should "be deletable" do
+      domain = Stripe::ApplePayDomain.retrieve(FIXTURE[:id])
+      domain = domain.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/apple_pay/domains/#{FIXTURE[:id]}"
+      assert domain.kind_of?(Stripe::ApplePayDomain)
+    end
+  end
+end

data/test/stripe/application_fee_refund_test.rb

@@ -2,46 +2,37 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ApplicationFeeRefundTest < Test::Unit::TestCase
-    should "refunds should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_application_fee))
+    FIXTURE = API_FIXTURES.fetch(:fee_refund)
 
-      application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
-
-      assert application_fee.refunds.first.kind_of?(Stripe::ApplicationFeeRefund)
+    setup do
+      application_fee_fixture = API_FIXTURES.fetch(:platform_earning)
+      @fee = Stripe::ApplicationFee.retrieve(application_fee_fixture[:id])
     end
 
-    should "refunds should be refreshable" do
-      @mock.expects(:get).twice.returns(make_response(make_application_fee), make_response(make_application_fee_refund(:id => 'refreshed_refund')))
+    should "be listable" do
+      refunds = @fee.refunds
 
-      application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
-      refund = application_fee.refunds.first
-      refund.refresh
+      # notably this *doesn't* make an API call
+      assert_not_requested :get,
+        "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds"
 
-      assert_equal 'refreshed_refund', refund.id
+      assert refunds.data.kind_of?(Array)
+      assert refunds.first.kind_of?(Stripe::ApplicationFeeRefund)
     end
 
-    should "refunds should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_application_fee))
-      @mock.expects(:post).once.returns(make_response(make_application_fee_refund(:metadata => {'key' => 'value'})))
-
-      application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
-      refund = application_fee.refunds.first
-
-      assert_equal nil, refund.metadata['key']
-
-      refund.metadata['key'] = 'valu'
-      refund.save
-
-      assert_equal 'value', refund.metadata['key']
+    should "be creatable" do
+      refund = @fee.refunds.create
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds"
+      assert refund.kind_of?(Stripe::ApplicationFeeRefund)
     end
 
-    should "create should return a new refund" do
-      @mock.expects(:get).once.returns(make_response(make_application_fee))
-      @mock.expects(:post).once.returns(make_response(make_application_fee_refund(:id => 'test_new_refund')))
-
-      application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
-      refund = application_fee.refunds.create(:amount => 20)
-      assert_equal 'test_new_refund', refund.id
+    should "be saveable" do
+      refund = @fee.refunds.first
+      refund.metadata['key'] = 'value'
+      refund.save
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds/#{FIXTURE[:id]}"
     end
   end
 end

data/test/stripe/application_fee_test.rb

@@ -2,21 +2,13 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ApplicationFeeTest < Test::Unit::TestCase
-    should "application fees should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_application_fee_array))
-      fees = Stripe::ApplicationFee.list
-      assert fees.data.kind_of? Array
-      fees.each do |fee|
-        assert fee.kind_of?(Stripe::ApplicationFee)
-      end
-    end
+    FIXTURE = API_FIXTURES.fetch(:platform_earning)
 
-    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
+    should "be listable" do
+      fees = Stripe::ApplicationFee.list
+      assert_requested :get, "#{Stripe.api_base}/v1/application_fees"
+      assert fees.data.kind_of?(Array)
+      assert fees.data[0].kind_of?(Stripe::ApplicationFee)
     end
   end
 end

data/test/stripe/balance_test.rb

@@ -2,10 +2,10 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class BalanceTest < Test::Unit::TestCase
-    should "balance should be retrievable" do
-      @mock.expects(:get).once.returns(make_response(make_balance))
+    should "be retrievable" do
       balance = Stripe::Balance.retrieve
-      assert_equal('balance', balance['object'])
+      assert_requested :get, "#{Stripe.api_base}/v1/balance"
+      assert balance.kind_of?(Stripe::Balance)
     end
   end
 end

data/test/stripe/bank_account_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class BankAccountTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:external_account_source)
+
+    context "#resource_url" do
+      should "return an external account URL" do
+        account_id = API_FIXTURES.fetch(:account)[:id]
+        bank_account = Stripe::BankAccount.construct_from(
+          account: account_id,
+          id: FIXTURE[:id]
+        )
+        assert_equal "/v1/accounts/#{account_id}/external_accounts/#{FIXTURE[:id]}",
+          bank_account.resource_url
+      end
+
+      should "return a customer URL" do
+        customer_id = API_FIXTURES.fetch(:customer)[:id]
+        bank_account = Stripe::BankAccount.construct_from(
+          customer: customer_id,
+          id: FIXTURE[:id]
+        )
+        assert_equal "/v1/customers/#{customer_id}/sources/#{FIXTURE[:id]}",
+          bank_account.resource_url
+      end
+    end
+
+    context "#verify" do
+      should 'verify the account' do
+        customer_id = API_FIXTURES.fetch(:customer)[:id]
+        bank_account = Stripe::BankAccount.construct_from({
+          customer: customer_id,
+          id: FIXTURE[:id]
+        })
+        bank_account = bank_account.verify(amounts: [1,2])
+        assert bank_account.kind_of?(Stripe::BankAccount)
+      end
+    end
+  end
+end

data/test/stripe/bitcoin_receiver_test.rb

@@ -2,60 +2,69 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class BitcoinReceiverTest < Test::Unit::TestCase
-    should "retrieve should retrieve bitcoin receiver" do
-      @mock.expects(:get).once.returns(make_response(make_bitcoin_receiver))
-      receiver = Stripe::BitcoinReceiver.retrieve('btcrcv_test_receiver')
-      assert_equal 'btcrcv_test_receiver', receiver.id
-    end
+    FIXTURE = API_FIXTURES.fetch(:bitcoin_receiver)
 
-    should "create should create a bitcoin receiver" do
-      @mock.expects(:post).once.returns(make_response(make_bitcoin_receiver))
-      receiver = Stripe::BitcoinReceiver.create
-      assert_equal "btcrcv_test_receiver", receiver.id
+    should "be listable" do
+      receivers = Stripe::BitcoinReceiver.list
+      assert_requested :get, "#{Stripe.api_base}/v1/bitcoin/receivers"
+      assert receivers.data.kind_of?(Array)
+      assert receivers.first.kind_of?(Stripe::BitcoinReceiver)
     end
 
-    should "all should list bitcoin receivers" do
-      @mock.expects(:get).once.returns(make_response(make_bitcoin_receiver_array))
-      receivers = Stripe::BitcoinReceiver.list
-      assert_equal 3, receivers.data.length
-      assert receivers.data.kind_of? Array
-      receivers.each do |receiver|
-        assert receiver.kind_of?(Stripe::BitcoinReceiver)
-        receiver.transactions.data.each do |transaction|
-          assert transaction.kind_of?(Stripe::BitcoinTransaction)
-        end
-      end
+    should "be retrievable" do
+      receiver = Stripe::BitcoinReceiver.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/bitcoin/receivers/#{FIXTURE[:id]}"
+      assert receiver.kind_of?(Stripe::BitcoinReceiver)
     end
 
-    should "maintain bitcoin transaction sublist" do
-      @mock.expects(:get).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, nil).once.returns(make_response(make_bitcoin_receiver))
-      receiver = Stripe::BitcoinReceiver.retrieve('btcrcv_test_receiver')
-      @mock.expects(:get).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver/transactions", nil, nil).once.returns(make_response(make_bitcoin_transaction_array))
-      transactions = receiver.transactions.list
-      assert_equal(3, transactions.data.length)
+    should "be creatable" do
+      receiver = Stripe::BitcoinReceiver.create(amount: 100, currency: "USD")
+      assert_requested :post, "#{Stripe.api_base}/v1/bitcoin/receivers"
+      assert receiver.kind_of?(Stripe::BitcoinReceiver)
     end
 
-    should "update should update a bitcoin receiver" do
-      @mock.expects(:get).once.returns(make_response(make_bitcoin_receiver))
-      @mock.expects(:post).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, "description=details").once.returns(make_response(make_bitcoin_receiver))
-      receiver = Stripe::BitcoinReceiver.construct_from(make_bitcoin_receiver)
-      receiver.refresh
-      receiver.description = "details"
+    should "be saveable" do
+      receiver = Stripe::BitcoinReceiver.retrieve(FIXTURE[:id])
+      receiver.metadata['key'] = 'value'
       receiver.save
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/bitcoin/receivers/#{FIXTURE[:id]}"
     end
 
-    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
-      assert(receiver.deleted)
+    should "be updateable" do
+      receiver = Stripe::BitcoinReceiver.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/bitcoin/receivers/#{FIXTURE[:id]}"
+      assert receiver.kind_of?(Stripe::BitcoinReceiver)
     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
-      assert(receiver.deleted)
+    should "be deletable" do
+      receiver = Stripe::BitcoinReceiver.retrieve(FIXTURE[:id])
+      receiver = receiver.delete
+      assert_requested :delete,
+        "#{Stripe.api_base}/v1/bitcoin/receivers/#{FIXTURE[:id]}"
+      assert receiver.kind_of?(Stripe::BitcoinReceiver)
+    end
+
+    context "#resource_url" do
+      should "return a customer URL" do
+        customer_id = API_FIXTURES.fetch(:customer)[:id]
+        receiver = Stripe::BitcoinReceiver.construct_from(
+          customer: customer_id,
+          id: FIXTURE[:id]
+        )
+        assert_equal "/v1/customers/#{customer_id}/sources/#{FIXTURE[:id]}",
+          receiver.resource_url
+      end
+
+      should "return an absolute URL" do
+        receiver = Stripe::BitcoinReceiver.construct_from(
+          id: FIXTURE[:id]
+        )
+        assert_equal "/v1/bitcoin/receivers/#{FIXTURE[:id]}",
+          receiver.resource_url
+      end
     end
   end
 end

data/test/stripe/bitcoin_transaction_test.rb

@@ -2,28 +2,20 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class BitcoinTransactionTest < Test::Unit::TestCase
-    TEST_ID = "btctxn_test_transaction".freeze
+    FIXTURE = API_FIXTURES.fetch(:bitcoin_transaction)
 
-    should "retrieve should retrieve bitcoin receiver" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/bitcoin/transactions/#{TEST_ID}", nil, nil).
-        once.
-        returns(make_response(make_bitcoin_transaction))
-      receiver = Stripe::BitcoinTransaction.retrieve(TEST_ID)
-      assert_equal TEST_ID, receiver.id
+    should "be listable" do
+      transactions = Stripe::BitcoinTransaction.list
+      assert_requested :get, "#{Stripe.api_base}/v1/bitcoin/transactions"
+      assert transactions.data.kind_of?(Array)
+      assert transactions.first.kind_of?(Stripe::BitcoinTransaction)
     end
 
-    should "all should list bitcoin transactions" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/bitcoin/transactions", nil, nil).
-        once.
-        returns(make_response(make_bitcoin_transaction_array))
-      transactions = Stripe::BitcoinTransaction.list
-      assert_equal 3, transactions.data.length
-      assert transactions.data.kind_of? Array
-      transactions.each do |transaction|
-        assert transaction.kind_of?(Stripe::BitcoinTransaction)
-      end
+    should "be retrievable" do
+      transaction = Stripe::BitcoinTransaction.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/bitcoin/transactions/#{FIXTURE[:id]}"
+      assert transaction.kind_of?(Stripe::BitcoinTransaction)
     end
   end
 end

data/test/stripe/charge_test.rb

@@ -2,117 +2,58 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ChargeTest < Test::Unit::TestCase
-    should "charges should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_charge_array))
-      c = Stripe::Charge.list
-      assert c.data.kind_of? Array
-      c.each do |charge|
-        assert charge.kind_of?(Stripe::Charge)
-      end
-    end
-
-    should "charges should be refundable" do
-      @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
-      assert c.refunded
-    end
+    FIXTURE = API_FIXTURES.fetch(:charge)
 
-    should "charges should not be deletable" do
-      assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(make_response(make_charge))
-        c = Stripe::Charge.retrieve("test_charge")
-        c.delete
-      end
+    should "be listable" do
+      charges = Stripe::Charge.list
+      assert_requested :get, "#{Stripe.api_base}/v1/charges"
+      assert charges.data.kind_of?(Array)
+      assert charges.data[0].kind_of?(Stripe::Charge)
     end
 
-    should "charges should be updateable" 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")
-      c.refresh
-      c.mnemonic = "New charge description"
-      c.save
+    should "be retrievable" do
+      charge = Stripe::Charge.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/charges/#{FIXTURE[:id]}"
+      assert charge.kind_of?(Stripe::Charge)
     end
 
-    should "charges should be able to be marked as fraudulent" 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")
-      c.refresh
-      c.mark_as_fraudulent
+    should "be creatable" do
+      charge = Stripe::Charge.create(
+        amount: 100,
+        currency: "USD",
+        source: API_FIXTURES.fetch(:source)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/charges"
+      assert charge.kind_of?(Stripe::Charge)
     end
 
-    should "charges should be able to be marked as safe" 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")
-      c.refresh
-      c.mark_as_safe
+    should "be saveable" do
+      charge = Stripe::Charge.retrieve(FIXTURE[:id])
+      charge.metadata['key'] = 'value'
+      charge.save
+      assert_requested :post, "#{Stripe.api_base}/v1/charges/#{FIXTURE[:id]}"
     end
 
-    should "charges should have Card objects associated with their Card property" 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'
+    should "be updateable" do
+      charge = Stripe::Charge.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/charges/#{FIXTURE[:id]}"
+      assert charge.kind_of?(Stripe::Charge)
     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) == {
-          'currency' => ['usd'], 'amount' => ['100'],
-          'card[exp_year]' => ['2012'],
-          'card[number]' => ['4242424242424242'],
-          'card[exp_month]' => ['11']
-        }
-      end.once.returns(make_response(make_charge))
-
-      c = Stripe::Charge.create({
-        :amount => 100,
-        :card => {
-          :number => "4242424242424242",
-          :exp_month => 11,
-          :exp_year => 2012,
-        },
-        :currency => "usd"
-      })
-      assert c.paid
-    end
-
-    should "execute should return a new, fully executed charge when passed correct `source` parameters" do
-      @mock.expects(:post).with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
-          'currency' => ['usd'], 'amount' => ['100'],
-          'source' => ['btcrcv_test_receiver']
-        }
-      end.once.returns(make_response(make_charge))
-
-      c = Stripe::Charge.create({
-        :amount => 100,
-        :source => 'btcrcv_test_receiver',
-        :currency => "usd"
-      })
-      assert c.paid
+    context "#mark_as_fraudulent" do
+      should "charges should be able to be marked as fraudulent" do
+        charge = Stripe::Charge.retrieve(FIXTURE[:id])
+        charge = charge.mark_as_fraudulent
+        assert charge.kind_of?(Stripe::Charge)
+      end
     end
 
-    should "properly handle an array or dictionaries" do
-      @mock.expects(:post).with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/charges" && api_key.nil? && CGI.parse(params) == {
-          'currency' => ['usd'], 'amount' => ['100'],
-          'source' => ['btcrcv_test_receiver'],
-          'level3[][red]' => ['firstred', 'another'],
-          'level3[][one]' => ['fish'],
-        }
-      end.once.returns(make_response(make_charge))
-
-      c = Stripe::Charge.create({
-        :amount => 100,
-        :source => 'btcrcv_test_receiver',
-        :currency => "usd",
-        :level3 => [{:red => 'firstred'}, {:one => 'fish', :red => 'another'}]
-      })
-      assert c.paid
+    context "#mark_as_safe" do
+      should "charges should be able to be marked as safe" do
+        charge = Stripe::Charge.retrieve(FIXTURE[:id])
+        charge = charge.mark_as_safe
+        assert charge.kind_of?(Stripe::Charge)
+      end
     end
   end
 end

data/test/stripe/country_spec_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class CountrySpecTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:country_spec)
+
+    should "be listable" do
+      c = Stripe::CountrySpec.list
+      assert_requested :get, "#{Stripe.api_base}/v1/country_specs"
+      assert c.data.kind_of?(Array)
+      assert c.data[0].kind_of?(Stripe::CountrySpec)
+    end
+
+    should "be retrievable" do
+      s = Stripe::CountrySpec.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/country_specs/#{FIXTURE[:id]}"
+      assert(s.kind_of?(Stripe::CountrySpec))
+    end
+  end
+end

data/test/stripe/coupon_test.rb

@@ -2,19 +2,43 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class CouponTest < Test::Unit::TestCase
-    should "create should return a new coupon" do
-      @mock.expects(:post).once.returns(make_response(make_coupon))
-      c = Stripe::Coupon.create
-      assert_equal "co_test_coupon", c.id
+    FIXTURE = API_FIXTURES.fetch(:coupon)
+
+    should "be listable" do
+      coupons = Stripe::Coupon.list
+      assert_requested :get, "#{Stripe.api_base}/v1/coupons"
+      assert coupons.data.kind_of?(Array)
+      assert coupons.first.kind_of?(Stripe::Coupon)
+    end
+
+    should "be retrievable" do
+      coupon = Stripe::Coupon.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/coupons/#{FIXTURE[:id]}"
+      assert coupon.kind_of?(Stripe::Coupon)
+    end
+
+    should "be creatable" do
+      coupon = Stripe::Coupon.create(
+        percent_off: 25,
+        duration: 'repeating',
+        duration_in_months: 3,
+        id: '25OFF'
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/coupons"
+      assert coupon.kind_of?(Stripe::Coupon)
+    end
+
+    should "be saveable" do
+      coupon = Stripe::Coupon.retrieve(FIXTURE[:id])
+      coupon.metadata['key'] = 'value'
+      coupon.save
+      assert_requested :post, "#{Stripe.api_base}/v1/coupons/#{FIXTURE[:id]}"
     end
 
-    should "coupons should be updateable" 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")
-      c.refresh
-      c.metadata['foo'] = 'bar'
-      c.save
+    should "be updateable" do
+      coupon = Stripe::Coupon.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/coupons/#{FIXTURE[:id]}"
+      assert coupon.kind_of?(Stripe::Coupon)
     end
   end
 end