stripe 1.31.0 → 1.58.0

data/test/stripe/stripe_object_test.rb

@@ -45,10 +45,23 @@ module Stripe
     end
 
     should "recursively call to_hash on its values" do
+      # deep nested hash (when contained in an array) or StripeObject
       nested_hash = { :id => 7, :foo => 'bar' }
       nested = Stripe::StripeObject.construct_from(nested_hash)
-      obj = Stripe::StripeObject.construct_from({ :id => 1, :nested => nested, :list => [nested] })
-      expected_hash = { :id => 1, :nested => nested_hash, :list => [nested_hash] }
+
+      obj = Stripe::StripeObject.construct_from({
+        :id     => 1,
+        # simple hash that contains a StripeObject to help us test deep
+        # recursion
+        :nested => { :object => 'list', :data => [nested] },
+        :list   => [nested]
+      })
+
+      expected_hash = {
+        :id     => 1,
+        :nested => { :object => 'list', :data => [nested_hash] },
+        :list   => [nested_hash]
+      }
       assert_equal expected_hash, obj.to_hash
     end
 
@@ -71,6 +84,19 @@ module Stripe
       assert_equal "foo", obj.unknown
     end
 
+    should "#update_attributes with a hash" do
+      obj = Stripe::StripeObject.construct_from({})
+      obj.update_attributes(:metadata => { :foo => 'bar' })
+      assert_equal Stripe::StripeObject, obj.metadata.class
+    end
+
+    should "create accessors when #update_attributes is called" do
+      obj = Stripe::StripeObject.construct_from({})
+      assert_equal false, obj.send(:metaclass).method_defined?(:foo)
+      obj.update_attributes(:foo => 'bar')
+      assert_equal true, obj.send(:metaclass).method_defined?(:foo)
+    end
+
     should "warn that #refresh_from is deprecated" do
       old_stderr = $stderr
       $stderr = StringIO.new
@@ -102,13 +128,20 @@ module Stripe
 
     should "#serialize_params on an empty object" do
       obj = Stripe::StripeObject.construct_from({})
-      assert_equal({}, Stripe::StripeObject.serialize_params(obj))
+      assert_equal({}, obj.serialize_params)
+    end
+
+    should "#serialize_params on a new object with a subobject" do
+      obj = Stripe::StripeObject.new
+      obj.metadata = { :foo => "bar" }
+      assert_equal({ :metadata => { :foo => "bar" } },
+        obj.serialize_params)
     end
 
     should "#serialize_params on a basic object" do
       obj = Stripe::StripeObject.construct_from({ :foo => nil })
       obj.update_attributes(:foo => "bar")
-      assert_equal({ :foo => "bar" }, Stripe::StripeObject.serialize_params(obj))
+      assert_equal({ :foo => "bar" }, obj.serialize_params)
     end
 
     should "#serialize_params on a more complex object" do
@@ -120,7 +153,7 @@ module Stripe
       })
       obj.foo.bar = "newbar"
       assert_equal({ :foo => { :bar => "newbar" } },
-        Stripe::StripeObject.serialize_params(obj))
+        obj.serialize_params)
     end
 
     should "#serialize_params on an array" do
@@ -129,7 +162,7 @@ module Stripe
       })
       obj.foo = ["new-value"]
       assert_equal({ :foo => ["new-value"] },
-        Stripe::StripeObject.serialize_params(obj))
+        obj.serialize_params)
     end
 
     should "#serialize_params on an array that shortens" do
@@ -138,7 +171,7 @@ module Stripe
       })
       obj.foo = ["new-value"]
       assert_equal({ :foo => ["new-value"] },
-        Stripe::StripeObject.serialize_params(obj))
+        obj.serialize_params)
     end
 
     should "#serialize_params on an array that lengthens" do
@@ -147,7 +180,7 @@ module Stripe
       })
       obj.foo = ["new-value"] * 4
       assert_equal({ :foo => ["new-value"] * 4 },
-        Stripe::StripeObject.serialize_params(obj))
+        obj.serialize_params)
     end
 
     should "#serialize_params on an array of hashes" do
@@ -161,12 +194,12 @@ module Stripe
       ]
       obj.foo[0].bar = "baz"
       assert_equal({ :foo => [{ :bar => "baz" }] },
-        Stripe::StripeObject.serialize_params(obj))
+        obj.serialize_params)
     end
 
     should "#serialize_params doesn't include unchanged values" do
       obj = Stripe::StripeObject.construct_from({ :foo => nil })
-      assert_equal({}, Stripe::StripeObject.serialize_params(obj))
+      assert_equal({}, obj.serialize_params)
     end
 
     should "#serialize_params on an array that is unchanged" do
@@ -174,7 +207,143 @@ module Stripe
         :foo => ["0-index", "1-index", "2-index"],
       })
       obj.foo = ["0-index", "1-index", "2-index"]
-      assert_equal({}, Stripe::StripeObject.serialize_params(obj))
+      assert_equal({}, obj.serialize_params)
+    end
+
+    should "#serialize_params with a StripeObject" do
+      obj = Stripe::StripeObject.construct_from({})
+
+      # using an #update_attributes will end up converting a Hash into a
+      # StripeObject
+      obj.metadata =
+        Stripe::StripeObject.construct_from({ :foo => 'bar' })
+
+      serialized = obj.serialize_params
+      assert_equal({ :foo => "bar" }, serialized[:metadata])
+    end
+
+    should "#serialize_params with a StripeObject that's been replaced" do
+      obj = Stripe::StripeObject.construct_from({
+        :metadata => Stripe::StripeObject.construct_from({ :bar => 'foo' })
+      })
+
+      # Here we replace the object wholesale which means that the client must
+      # be able to blank out the values that were in the old object, but which
+      # are no longer present in the new one.
+      obj.metadata =
+        Stripe::StripeObject.construct_from({ :baz => 'foo' })
+
+      serialized = obj.serialize_params
+      assert_equal({ :bar => "", :baz => 'foo' }, serialized[:metadata])
+    end
+
+    should "#serialize_params with an array of StripeObjects" do
+      obj = Stripe::StripeObject.construct_from({})
+      obj.metadata = [
+        Stripe::StripeObject.construct_from({ :foo => 'bar' })
+      ]
+
+      serialized = obj.serialize_params
+      assert_equal([{ :foo => "bar" }], serialized[:metadata])
+    end
+
+    should "#serialize_params and remove embedded APIResources" do
+      obj = Stripe::StripeObject.construct_from({
+        :customer => Customer.construct_from({})
+      })
+
+      serialized = obj.serialize_params
+      assert_equal({}, serialized)
+    end
+
+    should "#serialize_params and remove embedded APIResources unless flagged with save_with_parent" do
+      c = Customer.construct_from({})
+      c.save_with_parent = true
+
+      obj = Stripe::StripeObject.construct_from({
+        :customer => c,
+      })
+
+      serialized = obj.serialize_params
+      assert_equal({ :customer => {} }, serialized)
+    end
+
+    should "#serialize_params takes a force option" do
+      obj = Stripe::StripeObject.construct_from({
+        :id => 'id',
+        :metadata => Stripe::StripeObject.construct_from({ :foo => 'bar' })
+      })
+
+      serialized = obj.serialize_params(:force => true)
+      assert_equal({ :id => 'id', :metadata => { :foo => 'bar' } }, serialized)
+    end
+
+    should "#dirty! forces an object and its subobjects to be saved" do
+      obj = Stripe::StripeObject.construct_from({
+        :id => 'id',
+        :metadata => Stripe::StripeObject.construct_from({ :foo => 'bar' })
+      })
+
+      # note that `force` and `dirty!` are for different things, but are
+      # functionally equivalent
+      obj.dirty!
+
+      serialized = obj.serialize_params
+      assert_equal({ :id => 'id', :metadata => { :foo => 'bar' } }, serialized)
+    end
+
+    should "#to_s will call to_s for all embedded stripe objects" do
+      obj = Stripe::StripeObject.construct_from({
+        id: 'id',
+        #embeded list object
+        refunds: Stripe::ListObject.construct_from({ data: [
+          #embedded object in list
+          Stripe::StripeObject.construct_from({
+            id: 'id',
+            #embedded object in an object in a list object
+            metadata: Stripe::StripeObject.construct_from({
+              foo: 'bar',
+            })
+          })
+        ]}),
+        # embeded stripe object
+        metadata: Stripe::StripeObject.construct_from({
+          foo: 'bar',
+        })
+      })
+      expected = JSON.pretty_generate({
+        id: 'id',
+        refunds: {
+          data: [
+            {id: 'id', metadata: {foo: 'bar'}}
+          ]
+        },
+        metadata: { foo: 'bar' }
+      })
+
+      assert_equal(expected, obj.to_s)
+    end
+
+    should "warn that .serialize_params is deprecated" do
+      old_stderr = $stderr
+      $stderr = StringIO.new
+      begin
+        obj = Stripe::StripeObject.construct_from({})
+        Stripe::StripeObject.serialize_params(obj)
+        message = "NOTE: Stripe::StripeObject.serialize_params is " +
+          "deprecated; use #serialize_params instead"
+        assert_match Regexp.new(message), $stderr.string
+      ensure
+        $stderr = old_stderr
+      end
+    end
+
+    should "error on setting a property to an empty string" do
+      obj = Stripe::StripeObject.construct_from({ :foo => 'bar' })
+      e = assert_raises ArgumentError do
+        obj.foo = ""
+      end
+      assert_match %r{\(object\).foo = nil}, e.message
     end
   end
 end

data/test/stripe/subscription_item_test.rb

@@ -0,0 +1,76 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class SubscriptionItemTest < Test::Unit::TestCase
+    should "subscription items should be retrievable" do
+      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscription_items/si_test_subscription_item", nil, nil).
+        returns(make_response(make_subscription_item))
+
+      sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
+
+      assert sub_item.kind_of?(Stripe::SubscriptionItem)
+    end
+
+    should "subscription items should be listable" do
+      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscription_items?subscription=s_test_subscription&limit=3", nil, nil).
+        returns(make_response(make_subscription_item_array))
+      sub_items = Stripe::SubscriptionItem.list(:subscription => 's_test_subscription', :limit => 3).data
+
+      assert sub_items.kind_of? Array
+      assert sub_items[0].kind_of? Stripe::SubscriptionItem
+    end
+
+    should "subscription items should be deletable" do
+      @mock.expects(:get).once.returns(make_response(make_subscription_item))
+      sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
+
+      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}", nil, nil).
+        returns(make_response(make_subscription_item))
+      sub_item.delete
+    end
+
+    should "subscription items should be updateable" do
+      sid = 'si_test_subscription_item'
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscription_items/#{sid}" &&
+          api_key.nil? &&
+          CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
+      end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
+
+      sub_item = Stripe::SubscriptionItem.update(sid, {:plan => 'silver', :quantity => 3})
+
+      assert_equal 'silver', sub_item.plan.id
+      assert_equal 3, sub_item.quantity
+    end
+
+    should "subscription items should be saveable" do
+      @mock.expects(:get).once.returns(make_response(make_subscription_item))
+      sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
+
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}" &&
+          api_key.nil? &&
+          CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
+      end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
+
+      sub_item.plan = 'silver'
+      sub_item.quantity = 3
+      sub_item.save
+
+      assert_equal 'silver', sub_item.plan.id
+      assert_equal 3, sub_item.quantity
+    end
+
+    should "create should return a new subscription item" do
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscription_items" && api_key.nil? &&
+          CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
+      end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
+
+      sub_item = Stripe::SubscriptionItem.create(:plan => 'silver', :quantity => 3)
+
+      assert_equal 'silver', sub_item.plan.id
+      assert_equal 3, sub_item.quantity
+    end
+  end
+end

data/test/stripe/subscription_test.rb

@@ -2,71 +2,195 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class SubscriptionTest < Test::Unit::TestCase
-    should "subscriptions should be listable" do
+    should "subscriptions should be retrievable by customer" do
+      @mock.expects(:get).once.returns(make_response(make_customer))
+      customer = Stripe::Customer.retrieve('c_test_customer')
+
+      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/s_test_subscription", nil, nil).returns(make_response(make_subscription(:id => 's_test_subscription')))
+      _ = customer.subscriptions.retrieve('s_test_subscription')
+    end
+
+    should "subscriptions should be listable by customer" do
       @mock.expects(:get).once.returns(make_response(make_customer))
+      customer = Stripe::Customer.retrieve('c_test_customer')
+
+      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions", nil, nil).returns(make_response(make_customer_subscription_array('c_test_customer')))
+      subs = customer.subscriptions.all()
+
+      assert subs.kind_of?(Stripe::ListObject)
+      assert subs.data.kind_of?(Array)
+      assert subs.data[0].kind_of? Stripe::Subscription
+    end
+
+    should "subscriptions should be creatable by customer" do
+      @mock.expects(:get).once.returns(make_response(make_customer))
+      customer = Stripe::Customer.retrieve('c_test_customer')
+
+      @mock.expects(:post).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions", nil, 'plan=silver').returns(make_response(make_subscription(:id => 'test_new_subscription')))
+      subscription = customer.subscriptions.create(:plan => 'silver')
+
+      assert_equal 'test_new_subscription', subscription.id
+    end
+
+    should "subscriptions should be retrievable" do
+      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscriptions/s_test_subscription", nil, nil).returns(make_response(make_subscription))
+      sub = Stripe::Subscription.retrieve('s_test_subscription')
+
+      assert sub.kind_of?(Stripe::Subscription)
+    end
+
+    should "subscriptions should be listable" do
+      @mock.expects(:get).once.returns(make_response(make_subscription_array))
+      subs = Stripe::Subscription.list.data
+
+      assert subs.kind_of? Array
+      assert subs[0].kind_of? Stripe::Subscription
+    end
 
-      customer = Stripe::Customer.retrieve('test_customer')
+    should "subscriptions should be listable with filters" do
+      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscriptions?customer=c_test_customer&limit=3&plan=gold", nil, nil).returns(make_response(make_subscription_array))
+      subs = Stripe::Subscription.all(:customer => 'c_test_customer', :limit => 3, :plan => 'gold')
 
-      assert customer.subscriptions.first.kind_of?(Stripe::Subscription)
+      assert subs.kind_of?(Stripe::ListObject)
+      assert subs.data.kind_of?(Array)
+      assert subs.data[0].kind_of? Stripe::Subscription
     end
 
     should "subscriptions should be refreshable" do
-      @mock.expects(:get).twice.returns(make_response(make_customer), make_response(make_subscription(:id => 'refreshed_subscription')))
+      @mock.expects(:get).twice.returns(make_response(make_subscription(:id => 'refreshed_subscription')))
 
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.first
-      subscription.refresh
+      sub = Stripe::Subscription.retrieve('s_test_subscription')
+      sub.refresh
 
-      assert_equal 'refreshed_subscription', subscription.id
+      assert_equal 'refreshed_subscription', sub.id
     end
 
     should "subscriptions should be deletable" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.first
+      @mock.expects(:get).once.returns(make_response(make_subscription))
+      sub = Stripe::Subscription.retrieve('s_test_subscription')
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/#{subscription.id}?at_period_end=true", nil, nil).returns(make_response(make_subscription))
-      subscription.delete :at_period_end => true
+      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscriptions/#{sub.id}?at_period_end=true", nil, nil).returns(make_response(make_subscription))
+      sub.delete :at_period_end => true
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/#{subscription.id}", nil, nil).returns(make_response(make_subscription))
-      subscription.delete
+      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscriptions/#{sub.id}", nil, nil).returns(make_response(make_subscription))
+      sub.delete
     end
 
     should "subscriptions should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      @mock.expects(:post).once.returns(make_response(make_subscription({:status => 'active'})))
+      sid = 's_test_subscription'
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" && api_key.nil? && CGI.parse(params) == {'status' => ['active']}
+      end.returns(make_response(make_subscription(:status => 'active')))
 
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.first
-      assert_equal 'trialing', subscription.status
+      sub = Stripe::Subscription.update(sid, :status => 'active')
 
-      subscription.status = 'active'
-      subscription.save
+      assert_equal 'active', sub.status
+    end
 
-      assert_equal 'active', subscription.status
+    should "subscription items should be updateable" do
+      sid = 's_test_subscription'
+      items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
+
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" &&
+          api_key.nil? &&
+          CGI.parse(params) == {
+            'items[0][plan]' => ['gold'],
+            'items[0][quantity]' => ['1'],
+            'items[1][plan]' => ['silver'],
+            'items[1][quantity]' => ['2'],
+          }
+      end.returns(make_response(make_subscription(:items => items)))
+
+      sub = Stripe::Subscription.update(sid, :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
+
+      assert_equal 'gold', sub.items.data[0].plan.id
+      assert_equal 1, sub.items.data[0].quantity
+      assert_equal 'silver', sub.items.data[1].plan.id
+      assert_equal 2, sub.items.data[1].quantity
     end
 
-    should "create should return a new subscription" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      @mock.expects(:post).once.returns(make_response(make_subscription(:id => 'test_new_subscription')))
+    should "subscription items should be updateable with hash" do
+      sid = 's_test_subscription'
+      items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
+
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" &&
+          api_key.nil? &&
+          CGI.parse(params) == {
+            'items[0][plan]' => ['gold'],
+            'items[0][quantity]' => ['1'],
+            'items[1][plan]' => ['silver'],
+            'items[1][quantity]' => ['2'],
+          }
+      end.returns(make_response(make_subscription(:items => items)))
+
+      sub = Stripe::Subscription.update(sid, :items => {'0' => {:plan => 'gold', :quantity =>1}, '1' => {:plan => 'silver', :quantity =>2}})
+
+      assert_equal 'gold', sub.items.data[0].plan.id
+      assert_equal 1, sub.items.data[0].quantity
+      assert_equal 'silver', sub.items.data[1].plan.id
+      assert_equal 2, sub.items.data[1].quantity
+    end
 
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.create(:plan => 'silver')
-      assert_equal 'test_new_subscription', subscription.id
+    should "subscriptions should be saveable" do
+      @mock.expects(:get).once.returns(make_response(make_subscription))
+      sub = Stripe::Subscription.retrieve('s_test_subscription')
+      assert_equal 'trialing', sub.status
+
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscriptions/#{sub.id}" && api_key.nil? && CGI.parse(params) == {'status' => ['active']}
+      end.returns(make_response(make_subscription(:status => 'active')))
+
+      sub.status = 'active'
+      sub.save
+
+      assert_equal 'active', sub.status
     end
 
-    should "be able to delete a subscriptions's discount" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      @mock.expects(:post).once.returns(make_response(make_subscription(:id => 'test_new_subscription')))
+    should "create should return a new subscription" do
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscriptions" && api_key.nil? && CGI.parse(params) == {'customer' => ['c_test_customer'], 'plan' => ['gold']}
+      end.returns(make_response(make_subscription(:plan => 'gold', :id => 'test_new_subscription')))
 
+      sub = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer')
 
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.create(:plan => 'silver')
+      assert_equal 'test_new_subscription', sub.id
+      assert_equal 'gold', sub.plan.identifier
+    end
+
+    should "create with items should return a new subscription" do
+      items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
+
+      @mock.expects(:post).once.with do |url, api_key, params|
+        url == "#{Stripe.api_base}/v1/subscriptions" &&
+          api_key.nil? &&
+          CGI.parse(params) == {
+            'customer' => ['c_test_customer'],
+            'items[0][plan]' => ['gold'],
+            'items[0][quantity]' => ['1'],
+            'items[1][plan]' => ['silver'],
+            'items[1][quantity]' => ['2'],
+          }
+      end.returns(make_response(make_subscription(:items => items, :id => 'test_new_subscription')))
+
+      sub = Stripe::Subscription.create(:customer => 'c_test_customer', :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
+
+      assert_equal 'test_new_subscription', sub.id
+      assert_equal 'gold', sub.items.data[0].plan.id
+      assert_equal 1, sub.items.data[0].quantity
+      assert_equal 'silver', sub.items.data[1].plan.id
+      assert_equal 2, sub.items.data[1].quantity
+    end
+
+    should "be able to delete a subscriptions's discount" do
+      @mock.expects(:post).once.returns(make_response(make_subscription))
+      sub = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer', coupon: 'forever')
 
-      url = "#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/test_new_subscription/discount"
+      url = "#{Stripe.api_base}/v1/subscriptions/#{sub.id}/discount"
       @mock.expects(:delete).once.with(url, nil, nil).returns(make_response(make_delete_discount_response))
-      subscription.delete_discount
-      assert_equal nil, subscription.discount
+      sub.delete_discount
+      assert_equal nil, sub.discount
     end
   end
 end

data/test/stripe/three_d_secure_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class ThreeDSecureTest < Test::Unit::TestCase
+    should "retrieve an existing 3D Secure object" do
+      @mock.expects(:get).once.returns(make_response(make_three_d_secure))
+      tds = Stripe::ThreeDSecure.retrieve("tdsrc_test")
+      assert_equal "tdsrc_test", tds.id
+    end
+
+    should "create should return a new 3D Secure object" do
+      @mock.expects(:post).once.returns(make_response(make_three_d_secure))
+      tds = Stripe::ThreeDSecure.create(
+        :card => "tok_test",
+        :amount => 1500,
+        :currency => "usd",
+        :return_url => "https://example.org/3d-secure-result"
+      )
+      assert_equal "tdsrc_test", tds.id
+    end
+  end
+end

data/test/stripe/transfer_test.rb

@@ -14,6 +14,14 @@ module Stripe
       assert_equal "tr_test_transfer", transfer.id
     end
 
+    should "create should update a transfer" do
+      @mock.expects(:post).once.
+        with("#{Stripe.api_base}/v1/transfers/test_transfer", nil, "metadata[foo]=bar").
+        returns(make_response(make_transfer(metadata: {foo: 'bar'})))
+      transfer = Stripe::Transfer.update("test_transfer", metadata: {foo: 'bar'})
+      assert_equal "bar", transfer.metadata['foo']
+    end
+
     should "cancel should cancel a transfer" do
       @mock.expects(:get).once.returns(make_response(make_transfer))
       transfer = Stripe::Transfer.retrieve('tr_test_transfer')