stripe 1.30.3 → 2.0.0

data/test/stripe/list_object_test.rb

@@ -8,8 +8,10 @@ module Stripe
     end
 
     should "provide #count via enumerable" do
-      list = Stripe::ListObject.construct_from(make_charge_array)
-      assert_equal 3, list.count
+      list = Stripe::ListObject.construct_from({
+        data: [API_FIXTURES.fetch(:charge)]
+      })
+      assert_equal 1, list.count
     end
 
     should "provide #each" do
@@ -31,9 +33,14 @@ module Stripe
       ]
       expected = Util.convert_to_stripe_object(arr, {})
 
-      list = TestListObject.construct_from({ :data => [{ :id => 1 }], :has_more => true })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
-        returns(make_response({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
+      list = TestListObject.construct_from({
+        :data => [{ :id => 1 }],
+        :has_more => true,
+        :url => "/things",
+      })
+      stub_request(:get, "#{Stripe.api_base}/things").
+        with(query: { starting_after: "1" }).
+        to_return(body: JSON.generate({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
 
       assert_equal expected, list.auto_paging_each.to_a
     end
@@ -46,9 +53,14 @@ module Stripe
       ]
       expected = Util.convert_to_stripe_object(arr, {})
 
-      list = TestListObject.construct_from({ :data => [{ :id => 1 }], :has_more => true })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
-        returns(make_response({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
+      list = TestListObject.construct_from({
+        :data => [{ :id => 1 }],
+        :has_more => true,
+        :url => "/things",
+      })
+      stub_request(:get, "#{Stripe.api_base}/things").
+        with(query: { starting_after: "1" }).
+        to_return(body: JSON.generate({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
 
       actual = []
       list.auto_paging_each do |obj|
@@ -70,33 +82,38 @@ module Stripe
     #
 
     should "fetch a next page through #next_page" do
-      list = TestListObject.construct_from({ :data => [{ :id => 1 }], :has_more => true })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
-        returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
+      list = TestListObject.construct_from({
+        :data => [{ :id => 1 }],
+        :has_more => true,
+        :url => "/things",
+      })
+      stub_request(:get, "#{Stripe.api_base}/things").
+        with(query: { starting_after: "1" }).
+        to_return(body: JSON.generate({ :data => [{ :id => 2 }], :has_more => false }))
       next_list = list.next_page
       refute next_list.empty?
     end
 
     should "fetch a next page through #next_page and respect limit" do
-      list = TestListObject.construct_from({ :data => [{ :id => 1 }], :has_more => true })
+      list = TestListObject.construct_from({
+        :data => [{ :id => 1 }],
+        :has_more => true,
+        :url => "/things",
+      })
       list.filters = { :expand => ['data.source'], :limit => 3 }
-      @mock.expects(:get).with do |url, _, _|
-        # apparently URI.parse in 1.8.7 doesn't support query parameters ...
-        url, query = url.split("?")
-        u = URI.parse(url)
-        params = CGI.parse(query)
-        u.host == URI.parse(Stripe.api_base).host && u.path == "/things" && params == {
-          "expand[]"       => ["data.source"],
-          "limit"          => ["3"],
-          "starting_after" => ["1"],
-        }
-      end.returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
+      stub_request(:get, "#{Stripe.api_base}/things").
+        with(query: { "expand[]" => "data.source", "limit" => "3", "starting_after" => "1" }).
+        to_return(body: JSON.generate({ :data => [{ :id => 2 }], :has_more => false }))
       next_list = list.next_page
       assert_equal({ :expand => ['data.source'], :limit => 3 }, next_list.filters)
     end
 
     should "fetch an empty page through #next_page" do
-      list = TestListObject.construct_from({ :data => [{ :id => 1 }], :has_more => false })
+      list = TestListObject.construct_from({
+        :data => [{ :id => 1 }],
+        :has_more => false,
+        :url => "/things",
+      })
       next_list = list.next_page
       assert_equal Stripe::ListObject.empty_list, next_list
     end
@@ -106,27 +123,26 @@ module Stripe
     #
 
     should "fetch a next page through #previous_page" do
-      list = TestListObject.construct_from({ :data => [{ :id => 2 }] })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?ending_before=2", nil, nil).
-        returns(make_response({ :data => [{ :id => 1 }] }))
+      list = TestListObject.construct_from({
+        :data => [{ :id => 2 }],
+        :url => "/things",
+      })
+      stub_request(:get, "#{Stripe.api_base}/things").
+        with(query: { ending_before: "2" }).
+        to_return(body: JSON.generate({ :data => [{ :id => 1 }] }))
       next_list = list.previous_page
       refute next_list.empty?
     end
 
     should "fetch a next page through #previous_page and respect limit" do
-      list = TestListObject.construct_from({ :data => [{ :id => 2 }] })
+      list = TestListObject.construct_from({
+        :data => [{ :id => 2 }],
+        :url => "/things",
+      })
       list.filters = { :expand => ['data.source'], :limit => 3 }
-      @mock.expects(:get).with do |url, _, _|
-        # apparently URI.parse in 1.8.7 doesn't support query parameters ...
-        url, query = url.split("?")
-        u = URI.parse(url)
-        params = CGI.parse(query)
-        u.host == URI.parse(Stripe.api_base).host && u.path == "/things" && params == {
-          "ending_before" => ["2"],
-          "expand[]"      => ["data.source"],
-          "limit"         => ["3"],
-        }
-      end.returns(make_response({ :data => [{ :id => 1 }] }))
+      stub_request(:get, "#{Stripe.api_base}/things").
+        with(query: { "expand[]" => "data.source", "limit" => "3", "ending_before" => "2" }).
+        to_return(body: JSON.generate({ :data => [{ :id => 1 }] }))
       next_list = list.previous_page
       assert_equal({ :expand => ['data.source'], :limit => 3 }, next_list.filters)
     end
@@ -138,13 +154,12 @@ module Stripe
     # note that the name #all is deprecated, as is using it fetch the next page
     # in a list
     should "be able to retrieve full lists given a listobject" do
-      @mock.expects(:get).twice.returns(make_response(make_charge_array))
       c = Stripe::Charge.all
       assert c.kind_of?(Stripe::ListObject)
-      assert_equal('/v1/charges', c.url)
+      assert_equal('/v1/charges', c.resource_url)
       all = c.all
       assert all.kind_of?(Stripe::ListObject)
-      assert_equal('/v1/charges', all.url)
+      assert_equal('/v1/charges', all.resource_url)
       assert all.data.kind_of?(Array)
     end
   end
@@ -152,7 +167,4 @@ end
 
 # A helper class with a URL that allows us to try out pagination.
 class TestListObject < Stripe::ListObject
-  def url
-    "/things"
-  end
 end

data/test/stripe/order_return_test.rb

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

data/test/stripe/order_test.rb

@@ -2,51 +2,58 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class OrderTest < Test::Unit::TestCase
-    should "orders should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_order_array))
+    FIXTURE = API_FIXTURES.fetch(:order)
+
+    should "be listable" do
       orders = Stripe::Order.list
+      assert_requested :get, "#{Stripe.api_base}/v1/orders"
       assert orders.data.kind_of?(Array)
-      orders.each do |order|
-        assert order.kind_of?(Stripe::Order)
-      end
+      assert orders.first.kind_of?(Stripe::Order)
     end
 
-    should "orders should not be deletable" do
-      assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(make_response(make_order))
-        p = Stripe::Order.retrieve("test_order")
-        p.delete
-      end
+    should "be retrievable" do
+      order = Stripe::Order.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/orders/#{FIXTURE[:id]}"
+      assert order.kind_of?(Stripe::Order)
+    end
+
+    should "be creatable" do
+      order = Stripe::Order.create(
+        currency: "USD"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/orders"
+      assert order.kind_of?(Stripe::Order)
     end
 
-    should "orders should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_order))
-      @mock.expects(:post).once.returns(make_response(make_order))
-      p = Stripe::Order.new("test_order")
-      p.refresh
-      p.status = "fulfilled"
-      p.save
+    should "be saveable" do
+      order = Stripe::Order.retrieve(FIXTURE[:id])
+      order.metadata['key'] = 'value'
+      order.save
+      assert_requested :post, "#{Stripe.api_base}/v1/orders/#{FIXTURE[:id]}"
     end
 
-    should "orders should allow metadata updates" do
-      @mock.expects(:get).once.returns(make_response(make_order))
-      @mock.expects(:post).once.returns(make_response(make_order))
-      p = Stripe::Order.new("test_order")
-      p.refresh
-      p.metadata['key'] = 'value'
-      p.save
+    should "be updateable" do
+      order = Stripe::Order.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/orders/#{FIXTURE[:id]}"
+      assert order.kind_of?(Stripe::Order)
     end
 
-    should "pay should pay an order" do
-      @mock.expects(:get).once.
-        returns(make_response(make_order(:id => 'or_test_order')))
-      order = Stripe::Order.retrieve('or_test_order')
+    context "#pay" do
+      should "pay an order" do
+        order = Stripe::Order.retrieve(FIXTURE[:id])
+        order = order.pay(token: API_FIXTURES.fetch(:token)[:id])
+        assert order.kind_of?(Stripe::Order)
+      end
+    end
 
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/orders/or_test_order/pay', nil, 'token=test_token').
-        returns(make_response(make_paid_order))
-      order.pay(:token => 'test_token')
-      assert_equal "paid", order.status
+    context "#return_order" do
+      should "return an order" do
+        order = Stripe::Order.retrieve(FIXTURE[:id])
+        order = order.return_order(:orders => [
+          { parent: API_FIXTURES.fetch(:sku)[:id] }
+        ])
+        assert order.kind_of?(Stripe::OrderReturn)
+      end
     end
   end
 end

data/test/stripe/plan_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class PlanTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:plan)
+
+    should "be listable" do
+      plans = Stripe::Plan.list
+      assert_requested :get, "#{Stripe.api_base}/v1/plans"
+      assert plans.data.kind_of?(Array)
+      assert plans.data[0].kind_of?(Stripe::Plan)
+    end
+
+    should "be retrievable" do
+      plan = Stripe::Plan.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+      assert plan.kind_of?(Stripe::Plan)
+    end
+
+    should "be creatable" do
+      plan = Stripe::Plan.create(
+        amount: 5000,
+        interval: "month",
+        name: "Sapphire elite",
+        currency: "usd",
+        id: "sapphire-elite"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/plans"
+      assert plan.kind_of?(Stripe::Plan)
+    end
+
+    should "be saveable" do
+      plan = Stripe::Plan.retrieve(FIXTURE[:id])
+      plan.metadata['key'] = 'value'
+      plan.save
+      assert_requested :post, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+    end
+
+    should "be updateable" do
+      plan = Stripe::Plan.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+      assert plan.kind_of?(Stripe::Plan)
+    end
+
+    should "be deletable" do
+      plan = Stripe::Plan.retrieve(FIXTURE[:id])
+      plan = plan.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+      assert plan.kind_of?(Stripe::Plan)
+    end
+  end
+end

data/test/stripe/product_test.rb

@@ -2,40 +2,46 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ProductTest < Test::Unit::TestCase
-    should "products should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_product_array))
+    FIXTURE = API_FIXTURES.fetch(:product)
+
+    should "be listable" do
       products = Stripe::Product.list
+      assert_requested :get, "#{Stripe.api_base}/v1/products"
       assert products.data.kind_of?(Array)
-      products.each do |product|
-        assert product.kind_of?(Stripe::Product)
-      end
+      assert products.data[0].kind_of?(Stripe::Product)
+    end
+
+    should "be retrievable" do
+      product = Stripe::Product.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
+      assert product.kind_of?(Stripe::Product)
     end
 
-    should "products should not be deletable" do
-      assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(make_response(make_product))
-        p = Stripe::Product.retrieve("test_product")
-        p.delete
-      end
+    should "be creatable" do
+      _ = Stripe::Product.create(
+        name: "My Product"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/products"
     end
 
-    should "products should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_product))
-      @mock.expects(:post).once.returns(make_response(make_product))
-      p = Stripe::Product.new("test_product")
-      p.refresh
-      p.description = "New product description"
-      p.save
+    should "be saveable" do
+      product = Stripe::Product.retrieve(FIXTURE[:id])
+      product.metadata['key'] = 'value'
+      product.save
+      assert_requested :post, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
     end
 
-    should "products should allow metadata updates" do
-      @mock.expects(:get).once.returns(make_response(make_product))
-      @mock.expects(:post).once.returns(make_response(make_product))
-      p = Stripe::Product.new("test_product")
-      p.refresh
-      p.metadata['key'] = 'value'
-      p.save
+    should "be updateable" do
+      product = Stripe::Product.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
+      assert product.kind_of?(Stripe::Product)
     end
 
+    should "be deletable" do
+      product = Stripe::Product.retrieve(FIXTURE[:id])
+      product = product.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
+      assert product.kind_of?(Stripe::Product)
+    end
   end
 end

data/test/stripe/recipient_card_test.rb

@@ -2,56 +2,39 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class RecipientCardTest < Test::Unit::TestCase
-    RECIPIENT_CARD_URL = '/v1/recipients/test_recipient/cards/test_card'
+    FIXTURE = API_FIXTURES.fetch(:source)
 
-    def recipient
-      @mock.expects(:get).once.returns(make_response(make_recipient))
-      Stripe::Recipient.retrieve('test_recipient')
+    setup do
+      @recipient =
+        Stripe::Recipient.retrieve(API_FIXTURES.fetch(:transfer_recipient)[:id])
     end
 
-    should "recipient cards should be listable" do
-      c = recipient
-      @mock.expects(:get).once.returns(make_response(make_recipient_card_array(recipient.id)))
-      cards = c.cards.list.data
-      assert cards.kind_of? Array
-      assert cards[0].kind_of? Stripe::Card
+    should "be listable" do
+      cards = @recipient.cards.list
+      assert cards.data.kind_of?(Array)
+      assert cards.data[0].kind_of?(Stripe::Token)
     end
 
-    should "recipient cards should have the correct url" do
-      c = recipient
-      @mock.expects(:get).once.returns(make_response(make_card(
-        :id => 'test_card',
-        :recipient => 'test_recipient'
-      )))
-      card = c.cards.retrieve('card')
-      assert_equal RECIPIENT_CARD_URL, card.url
+    should "be creatable" do
+      card = @recipient.cards.create(
+        card: API_FIXTURES.fetch(:token)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards"
+      assert card.kind_of?(Stripe::Token)
     end
 
-    should "recipient cards should be deletable" do
-      c = recipient
-      @mock.expects(:get).once.returns(make_response(make_card))
-      @mock.expects(:delete).once.returns(make_response(make_card(:deleted => true)))
-      card = c.cards.retrieve('card')
-      card.delete
-      assert card.deleted
+    should "be deletable" do
+      card = Stripe::Card.construct_from(FIXTURE.merge(recipient: @recipient.id))
+      card = card.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards/#{FIXTURE[:id]}"
+      assert card.kind_of?(Stripe::Card)
     end
 
-    should "recipient cards should be updateable" do
-      c = recipient
-      @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.cards.retrieve('card')
-      assert_equal "2000", card.exp_year
-      card.exp_year = "2100"
+    should "be saveable" do
+      card = Stripe::Card.construct_from(FIXTURE.merge(recipient: @recipient.id))
+      card.metadata['key'] = 'value'
       card.save
-      assert_equal "2100", card.exp_year
-    end
-
-    should "create should return a new recipient card" do
-      c = recipient
-      @mock.expects(:post).once.returns(make_response(make_card(:id => "test_card")))
-      card = c.cards.create(:card => "tok_41YJ05ijAaWaFS")
-      assert_equal "test_card", card.id
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards/#{FIXTURE[:id]}"
     end
   end
 end

data/test/stripe/recipient_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class RecipientTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:transfer_recipient)
+
+    should "be listable" do
+      recipients = Stripe::Recipient.list
+      assert_requested :get, "#{Stripe.api_base}/v1/recipients"
+      assert recipients.data.kind_of?(Array)
+      assert recipients.data[0].kind_of?(Stripe::Recipient)
+    end
+
+    should "be retrievable" do
+      recipient = Stripe::Recipient.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+
+    should "be creatable" do
+      recipient = Stripe::Recipient.create(
+        name: "Noah Jackson",
+        type: "individual"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+
+    should "be saveable" do
+      recipient = Stripe::Recipient.retrieve(FIXTURE[:id])
+      recipient.metadata['key'] = 'value'
+      recipient.save
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+    end
+
+    should "be updateable" do
+      recipient = Stripe::Recipient.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+
+    should "be deletable" do
+      recipient = Stripe::Recipient.retrieve(FIXTURE[:id])
+      recipient = recipient.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+  end
+end
+

data/test/stripe/refund_test.rb

@@ -2,54 +2,38 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class RefundTest < Test::Unit::TestCase
-    should "refunds should be listable" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/refunds", nil, nil).
-        once.returns(make_response(make_refund_array))
+    FIXTURE = API_FIXTURES.fetch(:refund)
 
+    should "be listable" do
       refunds = Stripe::Refund.list
-
+      assert_requested :get, "#{Stripe.api_base}/v1/refunds"
+      assert refunds.data.kind_of?(Array)
       assert refunds.first.kind_of?(Stripe::Refund)
     end
 
-    should "refunds should be refreshable" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/refunds/test_refund", nil, nil).
-        twice.returns(make_response(make_refund(:id => 'test_refund')),
-                       make_response(make_refund(:id => 'refreshed_refund')))
-
-      refund = Stripe::Refund.retrieve('test_refund')
-      refund.refresh
-
-      assert_equal 'refreshed_refund', refund.id
+    should "be retrievable" do
+      refund = Stripe::Refund.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/refunds/#{FIXTURE[:id]}"
+      assert refund.kind_of?(Stripe::Refund)
     end
 
-    should "refunds should be updateable" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/refunds/get_refund", nil, nil).
-        once.returns(make_response(make_refund(:id => 'save_refund')))
-
-      @mock.expects(:post).
-        with("#{Stripe.api_base}/v1/refunds/save_refund", nil, 'metadata[key]=value').
-        once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
-
-      refund = Stripe::Refund.retrieve('get_refund')
-
-      assert_equal nil, refund.metadata['key']
+    should "be creatable" do
+      refund = Stripe::Refund.create(:charge => API_FIXTURES[:charge][:id])
+      assert_requested :post, "#{Stripe.api_base}/v1/refunds"
+      assert refund.kind_of?(Stripe::Refund)
+    end
 
+    should "be saveable" do
+      refund = Stripe::Refund.retrieve(FIXTURE[:id])
       refund.metadata['key'] = 'value'
       refund.save
-
-      assert_equal 'value', refund.metadata['key']
+      assert_requested :post, "#{Stripe.api_base}/v1/refunds/#{FIXTURE[:id]}"
     end
 
-    should "create should return a new refund" do
-      @mock.expects(:post).
-        with("#{Stripe.api_base}/v1/refunds", nil, 'charge=test_charge').
-        once.returns(make_response(make_refund(:id => 'test_new_refund')))
-
-      refund = Stripe::Refund.create(:charge => 'test_charge')
-      assert_equal 'test_new_refund', refund.id
+    should "be updateable" do
+      refund = Stripe::Refund.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/refunds/#{FIXTURE[:id]}"
+      assert refund.kind_of?(Stripe::Refund)
     end
   end
 end