stripe 1.18.0 → 1.30.0

data/test/stripe/api_resource_test.rb

@@ -37,6 +37,15 @@ module Stripe
       end
     end
 
+    should "using a nil api key should raise an exception" do
+      assert_raises TypeError do
+        Stripe::Customer.list({}, nil)
+      end
+      assert_raises TypeError do
+        Stripe::Customer.list({}, { :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
@@ -46,7 +55,7 @@ module Stripe
 
     should "specifying invalid api credentials should raise an exception" do
       Stripe.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
+      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")
@@ -55,7 +64,7 @@ module Stripe
 
     should "AuthenticationErrors should have an http status, http body, and JSON body" do
       Stripe.api_key = "invalid"
-      response = test_response(test_invalid_api_key_error, 401)
+      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")
@@ -63,15 +72,45 @@ module Stripe
         assert_equal(401, e.http_status)
         assert_equal(true, !!e.http_body)
         assert_equal(true, !!e.json_body[:error][:message])
-        assert_equal(test_invalid_api_key_error[:error][:message], 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(test_response(test_charge))
+      end.returns(make_response(make_charge))
 
       Stripe::Charge.create({:card => {:number => '4242424242424242'}},
                             {:stripe_account => stripe_account, :api_key => 'sk_test_local'})
@@ -80,18 +119,63 @@ module Stripe
     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(test_response(test_charge))
+      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(test_response(test_charge))
+          end.returns(make_response(make_charge))
 
           Stripe::Charge.create({:card => {:number => '4242424242424242'}},
             'sk_test_local')
@@ -110,7 +194,7 @@ module Stripe
         should "use the per-object credential when creating" do
           Stripe.expects(:execute_request).with do |opts|
             opts[:headers][:authorization] == 'Bearer local'
-          end.returns(test_response(test_charge))
+          end.returns(make_response(make_charge))
 
           Stripe::Charge.create({:card => {:number => '4242424242424242'}},
             'local')
@@ -120,11 +204,11 @@ module Stripe
           Stripe.expects(:execute_request).with do |opts|
             opts[:url] == "#{Stripe.api_base}/v1/charges/ch_test_charge" &&
               opts[:headers][:authorization] == 'Bearer local'
-          end.returns(test_response(test_charge))
+          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(test_response(test_charge))
+          end.returns(make_response(make_charge))
 
           ch = Stripe::Charge.retrieve('ch_test_charge', 'local')
           ch.refund
@@ -136,7 +220,7 @@ module Stripe
       should "send along the idempotency-key header" do
         Stripe.expects(:execute_request).with do |opts|
           opts[:headers][:idempotency_key] == 'bar'
-        end.returns(test_response(test_charge))
+        end.returns(make_response(make_charge))
 
         Stripe::Charge.create({:card => {:number => '4242424242424242'}}, {
           :idempotency_key => 'bar',
@@ -145,23 +229,23 @@ module Stripe
       end
 
       should "urlencode values in GET params" do
-        response = test_response(test_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
+        response = make_response(make_charge_array)
+        @mock.expects(:get).with("#{Stripe.api_base}/v1/charges?customer=test+customer", nil, nil).returns(response)
+        charges = Stripe::Charge.list(:customer => 'test customer').data
         assert charges.kind_of? Array
       end
 
       should "construct URL properly with base query parameters" do
-        response = test_response(test_invoice_customer_array)
+        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')
+        invoices = Stripe::Invoice.list(: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)
+        invoices.list(:paid => true)
       end
 
       should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 400)
+        response = make_response(make_missing_id_error, 400)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
           Stripe::Customer.retrieve("foo")
@@ -173,7 +257,7 @@ module Stripe
       end
 
       should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 401)
+        response = make_response(make_missing_id_error, 401)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
           Stripe::Customer.retrieve("foo")
@@ -185,7 +269,7 @@ module Stripe
       end
 
       should "a 402 should give a CardError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 402)
+        response = make_response(make_missing_id_error, 402)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
           Stripe::Customer.retrieve("foo")
@@ -197,7 +281,7 @@ module Stripe
       end
 
       should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
-        response = test_response(test_missing_id_error, 404)
+        response = make_response(make_missing_id_error, 404)
         @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
         begin
           Stripe::Customer.retrieve("foo")
@@ -208,25 +292,37 @@ module Stripe
         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(test_response({ :count => 1, :data => [test_charge] }))
-        Stripe::Charge.all(:count => nil, :offset => 5, :sad => false)
+        end.returns(make_response({ :count => 1, :data => [make_charge] }))
+        Stripe::Charge.list(: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(test_response({ :count => 1, :data => [test_charge] }))
+        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 = test_response(test_missing_id_error, 404)
+        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 }
@@ -239,26 +335,27 @@ module Stripe
 
       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(test_response([test_charge]))
-        Stripe::Charge.all(params)
+        @mock.expects(:get).once.with("#{Stripe.api_base}/v1/charges?limit=1", nil, nil).
+          returns(make_response({ :data => [make_charge] }))
+        Stripe::Charge.list(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(test_response(test_charge))
+        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(test_response(test_customer))
+        @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(test_response(test_customer))
+        @mock.expects(:get).once.returns(make_response(make_customer))
         c = Stripe::Customer.new("test_customer")
         c.refresh
         assert_equal c.created, c[:created]
@@ -268,7 +365,7 @@ module Stripe
       end
 
       should "accessing a property other than id or parent on an unfetched object should fetch it" do
-        @mock.expects(:get).once.returns(test_response(test_customer))
+        @mock.expects(:get).once.returns(make_response(make_customer))
         c = Stripe::Customer.new("test_customer")
         c.charges
       end
@@ -276,14 +373,14 @@ module Stripe
       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(test_response(test_customer))
-        c = Stripe::Customer.construct_from(test_customer)
+        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(test_response(test_customer))
+        @mock.expects(:post).once.returns(make_response(make_customer))
         c = Stripe::Customer.new("c_test_customer")
         c.description = "another_mn"
         c.save
@@ -293,9 +390,8 @@ module Stripe
       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(test_response({ "id" => "test_customer", "deleted" => true }))
-
-        c = Stripe::Customer.construct_from(test_customer)
+        @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
 
@@ -305,23 +401,50 @@ module Stripe
       end
 
       should "loading an object with properties that have specific types should instantiate those classes" 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
 
       should "loading all of an APIResource should return an array of recursively instantiated objects" do
-        @mock.expects(:get).once.returns(test_response(test_charge_array))
-        c = Stripe::Charge.all.data
+        @mock.expects(:get).once.returns(make_response(make_charge_array))
+        c = Stripe::Charge.list.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 = test_response(test_missing_id_error, 404)
+          response = make_response(make_missing_id_error, 404)
           @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
 
           rescued = false
@@ -339,7 +462,7 @@ module Stripe
         end
 
         should "5XXs should raise an APIError" do
-          response = test_response(test_api_error, 500)
+          response = make_response(make_api_error, 500)
           @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
 
           rescued = false
@@ -355,7 +478,7 @@ module Stripe
         end
 
         should "402s should raise a CardError" do
-          response = test_response(test_invalid_exp_year_error, 402)
+          response = make_response(make_invalid_exp_year_error, 402)
           @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 402))
 
           rescued = false
@@ -373,6 +496,167 @@ module Stripe
           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',
+            :address => {
+              :line1 => "test",
+              :city => "San Francisco"
+            }
+          }
+        })
+
+        @mock.expects(:post).once.with(
+          "#{Stripe.api_base}/v1/accounts/myid",
+          nil,
+          any_of(
+            'legal_entity[address][line1]=Test2&legal_entity[address][city]=',
+            'legal_entity[address][city]=&legal_entity[address][line1]=Test2'
+          )
+        ).returns(make_response({"id" => "myid"}))
+
+        acct.legal_entity.address = {:line1 => 'Test2'}
+        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
+
+      should 'should create a new resource when an object without an id is saved' do
+        account = Stripe::Account.construct_from({
+          :id => nil,
+          :display_name => nil,
+        })
+
+        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts", nil, 'display_name=stripe').
+          returns(make_response({"id" => "charge_id"}))
+
+        account.display_name = 'stripe'
+        account.save
+      end
+
+      should 'set attributes as part of save' do
+        account = Stripe::Account.construct_from({
+          :id => nil,
+          :display_name => nil,
+        })
+
+        @mock.expects(:post).once.with("#{Stripe.api_base}/v1/accounts", nil, 'display_name=stripe').
+          returns(make_response({"id" => "charge_id"}))
+
+        account.save(:display_name => 'stripe')
+      end
     end
   end
 end

data/test/stripe/application_fee_refund_test.rb

@@ -3,7 +3,7 @@ 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(test_response(test_application_fee))
+      @mock.expects(:get).once.returns(make_response(make_application_fee))
 
       application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
 
@@ -11,7 +11,7 @@ module Stripe
     end
 
     should "refunds should be refreshable" do
-      @mock.expects(:get).twice.returns(test_response(test_application_fee), test_response(test_application_fee_refund(:id => 'refreshed_refund')))
+      @mock.expects(:get).twice.returns(make_response(make_application_fee), make_response(make_application_fee_refund(:id => 'refreshed_refund')))
 
       application_fee = Stripe::ApplicationFee.retrieve('test_application_fee')
       refund = application_fee.refunds.first
@@ -21,8 +21,8 @@ module Stripe
     end
 
     should "refunds should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_application_fee))
-      @mock.expects(:post).once.returns(test_response(test_application_fee_refund(:metadata => {'key' => 'value'})))
+      @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
@@ -36,8 +36,8 @@ module Stripe
     end
 
     should "create should return a new refund" do
-      @mock.expects(:get).once.returns(test_response(test_application_fee))
-      @mock.expects(:post).once.returns(test_response(test_application_fee_refund(:id => 'test_new_refund')))
+      @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)

data/test/stripe/application_fee_test.rb

@@ -3,8 +3,8 @@ 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(test_response(test_application_fee_array))
-      fees = Stripe::ApplicationFee.all
+      @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)
@@ -13,7 +13,7 @@ module Stripe
 
     should "application fees should be refundable" do
       @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response({:id => "fee_test_fee", :refunded => true}))
+      @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

data/test/stripe/balance_test.rb

@@ -0,0 +1,11 @@
+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))
+      balance = Stripe::Balance.retrieve
+      assert_equal('balance', balance['object'])
+    end
+  end
+end