stripe 1.18.0 → 1.30.0

data/test/stripe/bitcoin_receiver_test.rb

@@ -3,20 +3,20 @@ 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(test_response(test_bitcoin_receiver))
+      @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
 
     should "create should create a bitcoin receiver" do
-      @mock.expects(:post).once.returns(test_response(test_bitcoin_receiver))
+      @mock.expects(:post).once.returns(make_response(make_bitcoin_receiver))
       receiver = Stripe::BitcoinReceiver.create
       assert_equal "btcrcv_test_receiver", receiver.id
     end
 
     should "all should list bitcoin receivers" do
-      @mock.expects(:get).once.returns(test_response(test_bitcoin_receiver_array))
-      receivers = Stripe::BitcoinReceiver.all
+      @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|
@@ -28,11 +28,34 @@ module Stripe
     end
 
     should "maintain bitcoin transaction sublist" do
-      @mock.expects(:get).with("#{Stripe.api_base}/v1/bitcoin/receivers/btcrcv_test_receiver", nil, nil).once.returns(test_response(test_bitcoin_receiver))
+      @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(test_response(test_bitcoin_transaction_array))
-      transactions = receiver.transactions.all
+      @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)
     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"
+      receiver.save
+    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)
+    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)
+    end
   end
 end

data/test/stripe/bitcoin_transaction_test.rb

@@ -0,0 +1,29 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class BitcoinTransactionTest < Test::Unit::TestCase
+    TEST_ID = "btctxn_test_transaction".freeze
+
+    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
+    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
+    end
+  end
+end

data/test/stripe/charge_refund_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class ChargeRefundTest < Test::Unit::TestCase
+    should "refunds should be listable" do
+      @mock.expects(:get).once.returns(make_response(make_charge))
+
+      charge = Stripe::Charge.retrieve('test_charge')
+
+      assert charge.refunds.first.kind_of?(Stripe::Refund)
+    end
+
+    should "refunds should be refreshable" do
+      @mock.expects(:get).twice.returns(make_response(make_charge), make_response(make_refund(:id => 'refreshed_refund')))
+
+      charge = Stripe::Charge.retrieve('test_charge')
+      refund = charge.refunds.first
+      refund.refresh
+
+      assert_equal 'refreshed_refund', refund.id
+    end
+
+    should "refunds should be updateable" do
+      @mock.expects(:get).
+        with("#{Stripe.api_base}/v1/charges/test_charge", nil, nil).
+        once.returns(make_response(make_charge))
+      @mock.expects(:post).
+        with("#{Stripe.api_base}/v1/refunds/ref_test_refund", nil, 'metadata[key]=value').
+        once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
+
+      charge = Stripe::Charge.retrieve('test_charge')
+      refund = charge.refunds.first
+
+      assert_equal nil, refund.metadata['key']
+
+      refund.metadata['key'] = 'value'
+      refund.save
+
+      assert_equal 'value', refund.metadata['key']
+    end
+
+    should "create should return a new refund" do
+      @mock.expects(:get).
+        with("#{Stripe.api_base}/v1/charges/test_charge", nil, nil).
+        once.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(:id => 'test_new_refund')))
+
+      charge = Stripe::Charge.retrieve('test_charge')
+      refund = charge.refunds.create(:amount => 20)
+      assert_equal 'test_new_refund', refund.id
+    end
+  end
+end

data/test/stripe/charge_test.rb

@@ -3,8 +3,8 @@ 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(test_response(test_charge_array))
-      c = Stripe::Charge.all
+      @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)
@@ -13,7 +13,7 @@ module Stripe
 
     should "charges should be refundable" do
       @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response({:id => "ch_test_charge", :refunded => true}))
+      @mock.expects(:post).once.returns(make_response({:id => "ch_test_charge", :refunded => true}))
       c = Stripe::Charge.new("test_charge")
       c.refund
       assert c.refunded
@@ -21,15 +21,15 @@ module Stripe
 
     should "charges should not be deletable" do
       assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(test_response(test_charge))
+        @mock.expects(:get).once.returns(make_response(make_charge))
         c = Stripe::Charge.retrieve("test_charge")
         c.delete
       end
     end
 
     should "charges should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      @mock.expects(:post).once.returns(test_response(test_charge))
+      @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"
@@ -37,23 +37,23 @@ module Stripe
     end
 
     should "charges should be able to be marked as fraudulent" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      @mock.expects(:post).once.returns(test_response(test_charge))
+      @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
     end
 
     should "charges should be able to be marked as safe" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      @mock.expects(:post).once.returns(test_response(test_charge))
+      @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
     end
 
     should "charges should have Card objects associated with their Card property" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
+      @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
@@ -66,7 +66,7 @@ module Stripe
           'card[number]' => ['4242424242424242'],
           'card[exp_month]' => ['11']
         }
-      end.once.returns(test_response(test_charge))
+      end.once.returns(make_response(make_charge))
 
       c = Stripe::Charge.create({
         :amount => 100,
@@ -86,7 +86,7 @@ module Stripe
           'currency' => ['usd'], 'amount' => ['100'],
           'source' => ['btcrcv_test_receiver']
         }
-      end.once.returns(test_response(test_charge))
+      end.once.returns(make_response(make_charge))
 
       c = Stripe::Charge.create({
         :amount => 100,
@@ -95,5 +95,24 @@ module Stripe
       })
       assert c.paid
     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
+    end
   end
 end

data/test/stripe/coupon_test.rb

@@ -3,14 +3,14 @@ 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(test_response(test_coupon))
+      @mock.expects(:post).once.returns(make_response(make_coupon))
       c = Stripe::Coupon.create
       assert_equal "co_test_coupon", c.id
     end
 
     should "coupons should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_coupon))
-      @mock.expects(:post).once.returns(test_response(test_coupon))
+      @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'

data/test/stripe/customer_card_test.rb

@@ -2,45 +2,45 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class CustomerCardTest < Test::Unit::TestCase
-    CUSTOMER_CARD_URL = '/v1/customers/test_customer/cards/test_card'
+    CUSTOMER_CARD_URL = '/v1/customers/test_customer/sources/test_card'
 
     def customer
-      @mock.expects(:get).once.returns(test_response(test_customer))
+      @mock.expects(:get).once.returns(make_response(make_customer))
       Stripe::Customer.retrieve('test_customer')
     end
 
     should "customer cards should be listable" do
       c = customer
-      @mock.expects(:get).once.returns(test_response(test_card_array(customer.id)))
-      cards = c.cards.all.data
+      @mock.expects(:get).once.returns(make_response(make_customer_card_array(customer.id)))
+      cards = c.sources.list(:object => "card").data
       assert cards.kind_of? Array
       assert cards[0].kind_of? Stripe::Card
     end
 
     should "customer cards should have the correct url" do
       c = customer
-      @mock.expects(:get).once.returns(test_response(test_card(
+      @mock.expects(:get).once.returns(make_response(make_card(
         :id => 'test_card',
         :customer => 'test_customer'
       )))
-      card = c.cards.retrieve('card')
+      card = c.sources.retrieve('card')
       assert_equal CUSTOMER_CARD_URL, card.url
     end
 
     should "customer cards should be deletable" do
       c = customer
-      @mock.expects(:get).once.returns(test_response(test_card))
-      @mock.expects(:delete).once.returns(test_response(test_card(:deleted => true)))
-      card = c.cards.retrieve('card')
+      @mock.expects(:get).once.returns(make_response(make_card))
+      @mock.expects(:delete).once.returns(make_response(make_card(:deleted => true)))
+      card = c.sources.retrieve('card')
       card.delete
       assert card.deleted
     end
 
     should "customer cards should be updateable" do
       c = customer
-      @mock.expects(:get).once.returns(test_response(test_card(:exp_year => "2000")))
-      @mock.expects(:post).once.returns(test_response(test_card(:exp_year => "2100")))
-      card = c.cards.retrieve('card')
+      @mock.expects(:get).once.returns(make_response(make_card(:exp_year => "2000")))
+      @mock.expects(:post).once.returns(make_response(make_card(:exp_year => "2100")))
+      card = c.sources.retrieve('card')
       assert_equal "2000", card.exp_year
       card.exp_year = "2100"
       card.save
@@ -49,9 +49,15 @@ module Stripe
 
     should "create should return a new customer card" do
       c = customer
-      @mock.expects(:post).once.returns(test_response(test_card(:id => "test_card")))
-      card = c.cards.create(:card => "tok_41YJ05ijAaWaFS")
+      @mock.expects(:post).once.returns(make_response(make_card(:id => "test_card")))
+      card = c.sources.create(:source => "tok_41YJ05ijAaWaFS")
       assert_equal "test_card", card.id
     end
+
+    should "raise if accessing Stripe::Card.retrieve directly" do
+      assert_raises NotImplementedError do
+        Stripe::Card.retrieve "card_12345"
+      end
+    end
   end
 end

data/test/stripe/customer_test.rb

@@ -3,22 +3,22 @@ require File.expand_path('../../test_helper', __FILE__)
 module Stripe
   class CustomerTest < Test::Unit::TestCase
     should "customers should be listable" do
-      @mock.expects(:get).once.returns(test_response(test_customer_array))
-      c = Stripe::Customer.all.data
+      @mock.expects(:get).once.returns(make_response(make_customer_array))
+      c = Stripe::Customer.list.data
       assert c.kind_of? Array
       assert c[0].kind_of? Stripe::Customer
     end
 
     should "customers should be deletable" do
-      @mock.expects(:delete).once.returns(test_response(test_customer({:deleted => true})))
+      @mock.expects(:delete).once.returns(make_response(make_customer({:deleted => true})))
       c = Stripe::Customer.new("test_customer")
       c.delete
       assert c.deleted
     end
 
     should "customers should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_customer({:mnemonic => "foo"})))
-      @mock.expects(:post).once.returns(test_response(test_customer({:mnemonic => "bar"})))
+      @mock.expects(:get).once.returns(make_response(make_customer({:mnemonic => "foo"})))
+      @mock.expects(:post).once.returns(make_response(make_customer({:mnemonic => "bar"})))
       c = Stripe::Customer.new("test_customer").refresh
       assert_equal "foo", c.mnemonic
       c.mnemonic = "bar"
@@ -27,24 +27,24 @@ module Stripe
     end
 
     should "create should return a new customer" do
-      @mock.expects(:post).once.returns(test_response(test_customer))
+      @mock.expects(:post).once.returns(make_response(make_customer))
       c = Stripe::Customer.create
       assert_equal "c_test_customer", c.id
     end
 
     should "create_upcoming_invoice should create a new invoice" do
-      @mock.expects(:post).once.returns(test_response(test_invoice))
+      @mock.expects(:post).once.returns(make_response(make_invoice))
       i = Stripe::Customer.new("test_customer").create_upcoming_invoice
       assert_equal "c_test_customer", i.customer
     end
 
     should "be able to update a customer's subscription" do
-      @mock.expects(:get).once.returns(test_response(test_customer))
+      @mock.expects(:get).once.returns(make_response(make_customer))
       c = Stripe::Customer.retrieve("test_customer")
 
       @mock.expects(:post).once.with do |url, api_key, params|
         url == "#{Stripe.api_base}/v1/customers/c_test_customer/subscription" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
-      end.returns(test_response(test_subscription(:plan => 'silver')))
+      end.returns(make_response(make_subscription(:plan => 'silver')))
       s = c.update_subscription({:plan => 'silver'})
 
       assert_equal 'subscription', s.object
@@ -52,15 +52,15 @@ module Stripe
     end
 
     should "be able to cancel a customer's subscription" do
-      @mock.expects(:get).once.returns(test_response(test_customer))
+      @mock.expects(:get).once.returns(make_response(make_customer))
       c = Stripe::Customer.retrieve("test_customer")
 
       # Not an accurate response, but whatever
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription?at_period_end=true", nil, nil).returns(test_response(test_subscription(:plan => 'silver')))
+      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription?at_period_end=true", nil, nil).returns(make_response(make_subscription(:plan => 'silver')))
       c.cancel_subscription({:at_period_end => 'true'})
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription", nil, nil).returns(test_response(test_subscription(:plan => 'silver')))
+      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription", nil, nil).returns(make_response(make_subscription(:plan => 'silver')))
       c.cancel_subscription
     end
 
@@ -69,7 +69,7 @@ module Stripe
 
       @mock.expects(:post).once.with do |url, api_key, params|
         url == "#{Stripe.api_base}/v1/customers/test_customer/subscriptions" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
-      end.returns(test_response(test_subscription(:plan => 'silver')))
+      end.returns(make_response(make_subscription(:plan => 'silver')))
       s = c.create_subscription({:plan => 'silver'})
 
       assert_equal 'subscription', s.object
@@ -77,10 +77,10 @@ module Stripe
     end
 
     should "be able to delete a customer's discount" do
-      @mock.expects(:get).once.returns(test_response(test_customer))
+      @mock.expects(:get).once.returns(make_response(make_customer))
       c = Stripe::Customer.retrieve("test_customer")
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/discount", nil, nil).returns(test_response(test_delete_discount_response))
+      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/discount", nil, nil).returns(make_response(make_delete_discount_response))
       c.delete_discount
       assert_equal nil, c.discount
     end

data/test/stripe/dispute_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class DisputeTest < Test::Unit::TestCase
+    should "disputes should be retrievable" do
+      @mock.expects(:get).once.returns(make_response(make_dispute))
+      d = Stripe::Dispute.retrieve('dp_test_dispute')
+      assert d.kind_of?(Stripe::Dispute)
+    end
+
+    should "disputes should be listable" do
+      @mock.expects(:get).once.returns(make_response(make_dispute_array))
+      d = Stripe::Dispute.list
+      assert d.data.kind_of? Array
+      d.each do |dispute|
+        assert dispute.kind_of?(Stripe::Dispute)
+      end
+    end
+
+    should "disputes should be closeable" do
+      @mock.expects(:get).never
+      @mock.expects(:post).with(
+        "#{Stripe.api_base}/v1/disputes/test_dispute/close",
+        nil,
+        ''
+      ).once.returns(make_response({:id => 'dp_test_dispute', :status => 'lost'}))
+      d = Stripe::Dispute.new('test_dispute')
+      d.close
+    end
+
+    should "disputes should be updateable" do
+      @mock.expects(:get).once.returns(make_response(make_dispute))
+      @mock.expects(:post).with(
+        "#{Stripe.api_base}/v1/disputes/dp_test_dispute",
+        nil,
+        'evidence[customer_name]=customer'
+      ).once.returns(make_response(make_dispute))
+
+      d = Stripe::Dispute.new('test_dispute')
+      d.refresh
+      d.evidence['customer_name'] = 'customer'
+      d.save
+    end
+  end
+end

data/test/stripe/file_upload_test.rb

@@ -3,24 +3,35 @@ require File.expand_path('../../test_helper', __FILE__)
 module Stripe
   class FileUploadTest < Test::Unit::TestCase
     should "create should return a new file" do
-      @mock.expects(:post).once.returns(test_response(test_file))
-      f = Stripe::FileUpload.create({
+      params = {
         :purpose => "dispute_evidence",
         :file => File.new(__FILE__),
-      })
+      }
+
+      @mock.expects(:post).once.
+        with("#{Stripe.uploads_base}/v1/files", nil, params).
+        returns(make_response(make_file))
+
+      f = Stripe::FileUpload.create(params)
       assert_equal "fil_test_file", f.id
     end
 
     should "files should be retrievable" do
-      @mock.expects(:get).once.returns(test_response(test_file))
+      @mock.expects(:get).once.
+        with("#{Stripe.uploads_base}/v1/files/fil_test_file", nil, nil).
+        returns(make_response(make_file))
+
       c = Stripe::FileUpload.new("fil_test_file")
       c.refresh
       assert_equal 1403047735, c.created
     end
 
     should "files should be listable" do
-      @mock.expects(:get).once.returns(test_response(test_file_array))
-      c = Stripe::FileUpload.all.data
+      @mock.expects(:get).once.
+        with("#{Stripe.uploads_base}/v1/files", nil, nil).
+        returns(make_response(make_file_array))
+
+      c = Stripe::FileUpload.list.data
       assert c.kind_of? Array
       assert c[0].kind_of? Stripe::FileUpload
     end

data/test/stripe/invoice_test.rb

@@ -3,22 +3,36 @@ require File.expand_path('../../test_helper', __FILE__)
 module Stripe
   class InvoiceTest < Test::Unit::TestCase
     should "retrieve should retrieve invoices" do
-      @mock.expects(:get).once.returns(test_response(test_invoice))
+      @mock.expects(:get).once.returns(make_response(make_invoice))
       i = Stripe::Invoice.retrieve('in_test_invoice')
       assert_equal 'in_test_invoice', i.id
     end
 
     should "create should create a new invoice" do
-      @mock.expects(:post).once.returns(test_response(test_invoice))
+      @mock.expects(:post).once.returns(make_response(make_invoice))
       i = Stripe::Invoice.create
       assert_equal "in_test_invoice", i.id
     end
 
     should "pay should pay an invoice" do
-      @mock.expects(:get).once.returns(test_response(test_invoice))
+      @mock.expects(:get).once.returns(make_response(make_invoice))
       i = Stripe::Invoice.retrieve('in_test_invoice')
 
-      @mock.expects(:post).once.with('https://api.stripe.com/v1/invoices/in_test_invoice/pay', nil, '').returns(test_response(test_paid_invoice))
+      @mock.expects(:post).once.with('https://api.stripe.com/v1/invoices/in_test_invoice/pay', nil, '').returns(make_response(make_paid_invoice))
+      i.pay
+      assert_equal nil, i.next_payment_attempt
+    end
+
+    should "pay with extra opts should pay an invoice" do
+      @mock.expects(:get).once.returns(make_response(make_invoice))
+      i = Stripe::Invoice.retrieve('in_test_invoice', {:api_key => 'foobar'})
+
+      Stripe.expects(:execute_request).with do |opts|
+        opts[:url] == "#{Stripe.api_base}/v1/invoices/in_test_invoice/pay" &&
+          opts[:method] == :post &&
+          opts[:headers][:authorization] == 'Bearer foobar'
+      end.returns(make_response(make_paid_invoice))
+
       i.pay
       assert_equal nil, i.next_payment_attempt
     end