stripe 1.30.3 → 2.0.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
@@ -90,9 +116,13 @@ module Stripe
 
       # customer comes with a `sources` list that makes a convenient object to
       # perform tests on
-      customer = Stripe::Customer.construct_from(make_customer, opts)
+      obj = Stripe::StripeObject.construct_from({
+        sources: [
+          {}
+        ]
+      }, opts)
 
-      source = customer.sources.first
+      source = obj.sources.first
       # Pulling `@opts` as an instance variable here is not ideal, but it's
       # important enough argument that the test here is worth it. we should
       # consider exposing it publicly on a future pull (and possibly renaming
@@ -102,13 +132,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 +157,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 +166,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 +175,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 +184,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 +198,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 +211,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/stripe_response_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class StripeResponseTest < Test::Unit::TestCase
+    context ".from_faraday_hash" do
+      should "converts to StripeResponse" do
+        body = '{"foo": "bar"}'
+        headers = { "Request-Id" => "request-id" }
+
+        http_resp = {
+          body: body,
+          headers: headers,
+          status: 200,
+        }
+
+        resp = StripeResponse.from_faraday_hash(http_resp)
+
+        assert_equal JSON.parse(body, symbolize_names: true), resp.data
+        assert_equal body, resp.http_body
+        assert_equal headers, resp.http_headers
+        assert_equal 200, resp.http_status
+        assert_equal "request-id", resp.request_id
+      end
+    end
+
+    context ".from_faraday_response" do
+      should "converts to StripeResponse" do
+        body = '{"foo": "bar"}'
+        headers = { "Request-Id" => "request-id" }
+
+        env = Faraday::Env.from(
+          :status => 200, :body => body,
+          :response_headers => headers)
+        http_resp = Faraday::Response.new(env)
+
+        resp = StripeResponse.from_faraday_response(http_resp)
+
+        assert_equal JSON.parse(body, symbolize_names: true), resp.data
+        assert_equal body, resp.http_body
+        assert_equal headers, resp.http_headers
+        assert_equal 200, resp.http_status
+        assert_equal "request-id", resp.request_id
+      end
+    end
+  end
+end

data/test/stripe/subscription_item_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class SubscriptionItemTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:subscription_item)
+
+    should "be listable" do
+      items = Stripe::SubscriptionItem.list(
+        subscription: API_FIXTURES.fetch(:subscription)[:id]
+      )
+      assert_requested :get, "#{Stripe.api_base}/v1/subscription_items",
+        query: { subscription: API_FIXTURES.fetch(:subscription)[:id] }
+      assert items.data.kind_of?(Array)
+      assert items.data[0].kind_of?(Stripe::SubscriptionItem)
+    end
+
+    should "be retrievable" do
+      item = Stripe::SubscriptionItem.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::SubscriptionItem)
+    end
+
+    should "be creatable" do
+      item = Stripe::SubscriptionItem.create(
+        item: 'silver',
+        plan: API_FIXTURES.fetch(:plan)[:id],
+        quantity: 3,
+        subscription: API_FIXTURES.fetch(:subscription)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/subscription_items"
+      assert item.kind_of?(Stripe::SubscriptionItem)
+    end
+
+    should "be saveable" do
+      item = Stripe::SubscriptionItem.retrieve(FIXTURE[:id])
+      item.quantity = 4
+      item.save
+      assert_requested :post, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+    end
+
+    should "be updateable" do
+      item = Stripe::SubscriptionItem.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::SubscriptionItem)
+    end
+
+    should "be deletable" do
+      item = Stripe::SubscriptionItem.retrieve(FIXTURE[:id])
+      item = item.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::SubscriptionItem)
+    end
+  end
+end

data/test/stripe/subscription_test.rb

@@ -2,71 +2,59 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class SubscriptionTest < Test::Unit::TestCase
-    should "subscriptions should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
+    FIXTURE = API_FIXTURES.fetch(:subscription)
 
-      customer = Stripe::Customer.retrieve('test_customer')
-
-      assert customer.subscriptions.first.kind_of?(Stripe::Subscription)
+    should "be listable" do
+      subscriptions = Stripe::Subscription.list
+      assert_requested :get, "#{Stripe.api_base}/v1/subscriptions"
+      assert subscriptions.data.kind_of?(Array)
+      assert subscriptions.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')))
-
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.first
-      subscription.refresh
-
-      assert_equal 'refreshed_subscription', subscription.id
+    should "be retrievable" do
+      subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
+      assert subscription.kind_of?(Stripe::Subscription)
     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(: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/customers/c_test_customer/subscriptions/#{subscription.id}", nil, nil).returns(make_response(make_subscription))
-      subscription.delete
+    should "be creatable" do
+      subscription = Stripe::Subscription.create(
+        customer: API_FIXTURES.fetch(:customer)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/subscriptions"
+      assert subscription.kind_of?(Stripe::Subscription)
     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'})))
-
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.first
-      assert_equal 'trialing', subscription.status
-
-      subscription.status = 'active'
+    should "be saveable" do
+      subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+      subscription.metadata['key'] = 'value'
       subscription.save
-
-      assert_equal 'active', subscription.status
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
     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')))
-
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.create(:plan => 'silver')
-      assert_equal 'test_new_subscription', subscription.id
+    should "be updateable" do
+      subscription = Stripe::Subscription.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
+      assert subscription.kind_of?(Stripe::Subscription)
     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')))
-
-
-      customer = Stripe::Customer.retrieve('test_customer')
-      subscription = customer.subscriptions.create(:plan => 'silver')
+    should "be deletable" do
+      subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+      subscription = subscription.delete
+      assert_requested :delete,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
+      assert subscription.kind_of?(Stripe::Subscription)
+    end
 
-      url = "#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/test_new_subscription/discount"
-      @mock.expects(:delete).once.with(url, nil, nil).returns(make_response(make_delete_discount_response))
-      subscription.delete_discount
-      assert_equal nil, subscription.discount
+    context "#delete_discount" do
+      should "be able to delete a subscriptions's discount" do
+        subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+        subscription = subscription.delete_discount
+        assert subscription.kind_of?(Stripe::Subscription)
+      end
     end
   end
 end

data/test/stripe/three_d_secure_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class ThreeDSecureTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:three_d_secure)
+
+    should "be retrievable" do
+      secure = Stripe::ThreeDSecure.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/3d_secure/#{FIXTURE[:id]}"
+      assert secure.kind_of?(Stripe::ThreeDSecure)
+    end
+
+    should "be creatable" do
+      _ = Stripe::ThreeDSecure.create(
+        card: API_FIXTURES.fetch(:token)[:id],
+        amount: 1500,
+        currency: "usd",
+        return_url: "https://example.org/3d-secure-result"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/3d_secure"
+    end
+  end
+end

data/test/stripe/transfer_test.rb

@@ -2,24 +2,49 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class TransferTest < Test::Unit::TestCase
-    should "retrieve should retrieve transfer" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
-      transfer = Stripe::Transfer.retrieve('tr_test_transfer')
-      assert_equal 'tr_test_transfer', transfer.id
+    FIXTURE = API_FIXTURES.fetch(:transfer)
+
+    should "be listable" do
+      transfers = Stripe::Transfer.list
+      assert_requested :get, "#{Stripe.api_base}/v1/transfers"
+      assert transfers.data.kind_of?(Array)
+      assert transfers.data[0].kind_of?(Stripe::Transfer)
+    end
+
+    should "be retrievable" do
+      transfer = Stripe::Transfer.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/transfers/#{FIXTURE[:id]}"
+      assert transfer.kind_of?(Stripe::Transfer)
     end
 
-    should "create should create a transfer" do
-      @mock.expects(:post).once.returns(make_response(make_transfer))
-      transfer = Stripe::Transfer.create
-      assert_equal "tr_test_transfer", transfer.id
+    should "be creatable" do
+      transfer = Stripe::Transfer.create(
+        amount: 100,
+        currency: "USD"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/transfers"
+      assert transfer.kind_of?(Stripe::Transfer)
     end
 
-    should "cancel should cancel a transfer" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
-      transfer = Stripe::Transfer.retrieve('tr_test_transfer')
+    should "be saveable" do
+      transfer = Stripe::Transfer.retrieve(FIXTURE[:id])
+      transfer.metadata['key'] = 'value'
+      transfer.save
+      assert_requested :post, "#{Stripe.api_base}/v1/transfers/#{FIXTURE[:id]}"
+    end
+
+    should "be updateable" do
+      transfer = Stripe::Transfer.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/transfers/#{FIXTURE[:id]}"
+      assert transfer.kind_of?(Stripe::Transfer)
+    end
 
-      @mock.expects(:post).once.with('https://api.stripe.com/v1/transfers/tr_test_transfer/cancel', nil, '').returns(make_response(make_canceled_transfer))
-      transfer.cancel
+    context "#cancel" do
+      should "cancel a transfer" do
+        transfer = Stripe::Transfer.retrieve(FIXTURE[:id])
+        transfer = transfer.cancel
+        assert transfer.kind_of?(Stripe::Transfer)
+      end
     end
   end
 end

data/test/stripe/util_test.rb

@@ -3,23 +3,51 @@ require File.expand_path('../../test_helper', __FILE__)
 module Stripe
   class UtilTest < Test::Unit::TestCase
     should "#encode_parameters should prepare parameters for an HTTP request" do
-      # use array instead of hash for 1.8.7 ordering
-      params = [
-        [:a, 3],
-        [:b, "+foo?"],
-        [:c, "bar&baz"],
-        [:d, { :a => "a", :b => "b" }],
-        [:e, [0, 1]],
+      params = {
+        :a => 3,
+        :b => "+foo?",
+        :c => "bar&baz",
+        :d => { :a => "a", :b => "b" },
+        :e => [0, 1],
+        :f => "",
 
         # note the empty hash won't even show up in the request
-        [:f, []]
-      ]
+        :g => [],
+      }
       assert_equal(
-        "a=3&b=%2Bfoo%3F&c=bar%26baz&d[a]=a&d[b]=b&e[]=0&e[]=1",
+        "a=3&b=%2Bfoo%3F&c=bar%26baz&d[a]=a&d[b]=b&e[]=0&e[]=1&f=",
         Stripe::Util.encode_parameters(params)
       )
     end
 
+    should "#encode_params should throw an error on an array of maps that cannot be encoded" do
+      params = {
+        :a => [
+          { :a => 1, :b => 2 },
+          { :c => 3, :a => 4 },
+        ]
+      }
+      e = assert_raises(ArgumentError) do
+        Stripe::Util.encode_parameters(params)
+      end
+      expected = "All maps nested in an array should start with the same key " +
+        "(expected starting key 'a', got 'c')"
+      assert_equal expected, e.message
+
+      # Make sure the check is recursive by taking our original params and
+      # nesting it into yet another map and array. Should throw exactly the
+      # same error because it's still the in inner array of maps that's wrong.
+      params = {
+        :x => [
+          params
+        ]
+      }
+      e = assert_raises(ArgumentError) do
+        Stripe::Util.encode_parameters(params)
+      end
+      assert_equal expected, e.message
+    end
+
     should "#url_encode should prepare strings for HTTP" do
       assert_equal "foo",      Stripe::Util.url_encode("foo")
       assert_equal "foo",      Stripe::Util.url_encode(:foo)
@@ -36,8 +64,8 @@ module Stripe
         [:d, { :a => "a", :b => "b" }],
         [:e, [0, 1]],
         [:f, [
-          { :bar => "1", :foo => "2" },
-          { :baz => "3", :foo => "4" },
+          { :foo => "1", :ghi => "2" },
+          { :foo => "3", :bar => "4" },
         ]],
       ]
       assert_equal([
@@ -52,10 +80,10 @@ module Stripe
         # *The key here is the order*. In order to be properly interpreted as
         # an array of hashes on the server, everything from a single hash must
         # come in at once. A duplicate key in an array triggers a new element.
-        ["f[][bar]", "1"],
-        ["f[][foo]", "2"],
-        ["f[][baz]", "3"],
-        ["f[][foo]", "4"],
+        ["f[][foo]", "1"],
+        ["f[][ghi]", "2"],
+        ["f[][foo]", "3"],
+        ["f[][bar]", "4"],
       ], Stripe::Util.flatten_params(params))
     end
 
@@ -113,5 +141,9 @@ module Stripe
       obj = Util.convert_to_stripe_object([1, 2, 3], {})
       assert_equal [1, 2, 3], obj
     end
+
+    should "#array_to_hash should convert an array into a hash with integer keys" do
+      assert_equal({"0" => 1, "1" => 2, "2" => 3}, Util.array_to_hash([1, 2, 3]))
+    end
   end
 end