stripe 3.3.2 → 3.4.1

data/test/stripe/stripe_response_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class StripeResponseTest < Test::Unit::TestCase
@@ -29,8 +29,9 @@ module Stripe
         headers = { "Request-Id" => "request-id" }
 
         env = Faraday::Env.from(
-          :status => 200, :body => body,
-          :response_headers => headers)
+          status: 200, body: body,
+          response_headers: headers
+        )
         http_resp = Faraday::Response.new(env)
 
         resp = StripeResponse.from_faraday_response(http_resp)

data/test/stripe/subscription_item_test.rb

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

data/test/stripe/subscription_test.rb

@@ -1,19 +1,19 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class SubscriptionTest < Test::Unit::TestCase
     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)
+      assert subscriptions.data.is_a?(Array)
+      assert subscriptions.data[0].is_a?(Stripe::Subscription)
     end
 
     should "be retrievable" do
       subscription = Stripe::Subscription.retrieve("sub_123")
       assert_requested :get,
-        "#{Stripe.api_base}/v1/subscriptions/sub_123"
-      assert subscription.kind_of?(Stripe::Subscription)
+                       "#{Stripe.api_base}/v1/subscriptions/sub_123"
+      assert subscription.is_a?(Stripe::Subscription)
     end
 
     should "be creatable" do
@@ -21,37 +21,37 @@ module Stripe
         customer: "cus_123"
       )
       assert_requested :post, "#{Stripe.api_base}/v1/subscriptions"
-      assert subscription.kind_of?(Stripe::Subscription)
+      assert subscription.is_a?(Stripe::Subscription)
     end
 
     should "be saveable" do
       subscription = Stripe::Subscription.retrieve("sub_123")
-      subscription.metadata['key'] = 'value'
+      subscription.metadata["key"] = "value"
       subscription.save
       assert_requested :post,
-        "#{Stripe.api_base}/v1/subscriptions/#{subscription.id}"
+                       "#{Stripe.api_base}/v1/subscriptions/#{subscription.id}"
     end
 
     should "be updateable" do
-      subscription = Stripe::Subscription.update("sub_123", metadata: {foo: 'bar'})
+      subscription = Stripe::Subscription.update("sub_123", metadata: { foo: "bar" })
       assert_requested :post,
-        "#{Stripe.api_base}/v1/subscriptions/sub_123"
-      assert subscription.kind_of?(Stripe::Subscription)
+                       "#{Stripe.api_base}/v1/subscriptions/sub_123"
+      assert subscription.is_a?(Stripe::Subscription)
     end
 
     should "be deletable" do
       subscription = Stripe::Subscription.retrieve("sub_123")
       subscription = subscription.delete
       assert_requested :delete,
-        "#{Stripe.api_base}/v1/subscriptions/#{subscription.id}"
-      assert subscription.kind_of?(Stripe::Subscription)
+                       "#{Stripe.api_base}/v1/subscriptions/#{subscription.id}"
+      assert subscription.is_a?(Stripe::Subscription)
     end
 
     context "#delete_discount" do
       should "be able to delete a subscriptions's discount" do
         subscription = Stripe::Subscription.retrieve("sub_123")
         subscription = subscription.delete_discount
-        assert subscription.kind_of?(Stripe::Subscription)
+        assert subscription.is_a?(Stripe::Subscription)
       end
     end
   end

data/test/stripe/three_d_secure_test.rb

@@ -1,11 +1,11 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class ThreeDSecureTest < Test::Unit::TestCase
     should "be retrievable" do
       secure = Stripe::ThreeDSecure.retrieve("tdsrc_123")
       assert_requested :get, "#{Stripe.api_base}/v1/3d_secure/tdsrc_123"
-      assert secure.kind_of?(Stripe::ThreeDSecure)
+      assert secure.is_a?(Stripe::ThreeDSecure)
     end
 
     should "be creatable" do

data/test/stripe/transfer_test.rb

@@ -1,18 +1,18 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path("../../test_helper", __FILE__)
 
 module Stripe
   class TransferTest < Test::Unit::TestCase
     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)
+      assert transfers.data.is_a?(Array)
+      assert transfers.data[0].is_a?(Stripe::Transfer)
     end
 
     should "be retrievable" do
       transfer = Stripe::Transfer.retrieve("tr_123")
       assert_requested :get, "#{Stripe.api_base}/v1/transfers/tr_123"
-      assert transfer.kind_of?(Stripe::Transfer)
+      assert transfer.is_a?(Stripe::Transfer)
     end
 
     should "be creatable" do
@@ -22,20 +22,20 @@ module Stripe
         destination: "acct_123"
       )
       assert_requested :post, "#{Stripe.api_base}/v1/transfers"
-      assert transfer.kind_of?(Stripe::Transfer)
+      assert transfer.is_a?(Stripe::Transfer)
     end
 
     should "be saveable" do
       transfer = Stripe::Transfer.retrieve("tr_123")
-      transfer.metadata['key'] = 'value'
+      transfer.metadata["key"] = "value"
       transfer.save
       assert_requested :post, "#{Stripe.api_base}/v1/transfers/#{transfer.id}"
     end
 
     should "be updateable" do
-      transfer = Stripe::Transfer.update("tr_123", metadata: {foo: 'bar'})
+      transfer = Stripe::Transfer.update("tr_123", metadata: { foo: "bar" })
       assert_requested :post, "#{Stripe.api_base}/v1/transfers/tr_123"
-      assert transfer.kind_of?(Stripe::Transfer)
+      assert transfer.is_a?(Stripe::Transfer)
     end
   end
 end

data/test/stripe/util_test.rb

@@ -1,18 +1,18 @@
-require File.expand_path('../../test_helper', __FILE__)
+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
       params = {
-        :a => 3,
-        :b => "+foo?",
-        :c => "bar&baz",
-        :d => { :a => "a", :b => "b" },
-        :e => [0, 1],
-        :f => "",
+        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
-        :g => [],
+        g: [],
       }
       assert_equal(
         "a=3&b=%2Bfoo%3F&c=bar%26baz&d[a]=a&d[b]=b&e[]=0&e[]=1&f=",
@@ -22,25 +22,25 @@ module Stripe
 
     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 },
-        ]
+        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')"
+      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
-        ]
+        x: [
+          params,
+        ],
       }
       e = assert_raises(ArgumentError) do
         Stripe::Util.encode_parameters(params)
@@ -61,15 +61,15 @@ module Stripe
         [:a, 3],
         [:b, "foo?"],
         [:c, "bar&baz"],
-        [:d, { :a => "a", :b => "b" }],
+        [:d, { a: "a", b: "b" }],
         [:e, [0, 1]],
         [:f, [
-          { :foo => "1", :ghi => "2" },
-          { :foo => "3", :bar => "4" },
-        ]],
+          { foo: "1", ghi: "2" },
+          { foo: "3", bar: "4" },
+        ],],
       ]
       assert_equal([
-        ["a",        3],
+        ["a", 3],
         ["b",        "foo?"],
         ["c",        "bar&baz"],
         ["d[a]",     "a"],
@@ -89,22 +89,22 @@ module Stripe
 
     should "#symbolize_names should convert names to symbols" do
       start = {
-        'foo' => 'bar',
-        'array' => [{ 'foo' => 'bar' }],
-        'nested' => {
+        "foo" => "bar",
+        "array" => [{ "foo" => "bar" }],
+        "nested" => {
           1 => 2,
           :symbol => 9,
-          'string' => nil
-        }
+          "string" => nil,
+        },
       }
       finish = {
-        :foo => 'bar',
-        :array => [{ :foo => 'bar' }],
-        :nested => {
+        foo: "bar",
+        array: [{ foo: "bar" }],
+        nested: {
           1 => 2,
           :symbol => 9,
-          :string => nil
-        }
+          :string => nil,
+        },
       }
 
       symbolized = Stripe::Util.symbolize_names(start)
@@ -113,7 +113,7 @@ module Stripe
 
     should "#normalize_opts should reject nil keys" do
       assert_raise { Stripe::Util.normalize_opts(nil) }
-      assert_raise { Stripe::Util.normalize_opts(:api_key => nil) }
+      assert_raise { Stripe::Util.normalize_opts(api_key: nil) }
     end
 
     should "#convert_to_stripe_object should pass through unknown types" do
@@ -122,18 +122,18 @@ module Stripe
     end
 
     should "#convert_to_stripe_object should turn hashes into StripeObjects" do
-      obj = Util.convert_to_stripe_object({ :foo => "bar" }, {})
+      obj = Util.convert_to_stripe_object({ foo: "bar" }, {})
       assert obj.is_a?(StripeObject)
       assert_equal "bar", obj.foo
     end
 
     should "#convert_to_stripe_object should turn lists into ListObjects" do
-      obj = Util.convert_to_stripe_object({ :object => "list" }, {})
+      obj = Util.convert_to_stripe_object({ object: "list" }, {})
       assert obj.is_a?(ListObject)
     end
 
     should "#convert_to_stripe_object should marshal other classes" do
-      obj = Util.convert_to_stripe_object({ :object => "account" }, {})
+      obj = Util.convert_to_stripe_object({ object: "account" }, {})
       assert obj.is_a?(Account)
     end
 
@@ -143,23 +143,23 @@ module Stripe
     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]))
+      assert_equal({ "0" => 1, "1" => 2, "2" => 3 }, Util.array_to_hash([1, 2, 3]))
     end
 
     context ".request_id_dashboard_url" do
       should "generate a livemode URL" do
         assert_equal "https://dashboard.stripe.com/live/logs/request-id",
-          Util.request_id_dashboard_url("request-id", "sk_live_123")
+                     Util.request_id_dashboard_url("request-id", "sk_live_123")
       end
 
       should "generate a testmode URL" do
         assert_equal "https://dashboard.stripe.com/test/logs/request-id",
-          Util.request_id_dashboard_url("request-id", "sk_test_123")
+                     Util.request_id_dashboard_url("request-id", "sk_test_123")
       end
 
       should "default to a testmode URL" do
         assert_equal "https://dashboard.stripe.com/test/logs/request-id",
-          Util.request_id_dashboard_url("request-id", nil)
+                     Util.request_id_dashboard_url("request-id", nil)
       end
     end
 
@@ -296,20 +296,20 @@ module Stripe
     context ".normalize_headers" do
       should "normalize the format of a header key" do
         assert_equal({ "Request-Id" => nil },
-          Util.normalize_headers({ "Request-Id" => nil }))
+                     Util.normalize_headers("Request-Id" => nil))
         assert_equal({ "Request-Id" => nil },
-          Util.normalize_headers({ "request-id" => nil }))
+                     Util.normalize_headers("request-id" => nil))
         assert_equal({ "Request-Id" => nil },
-          Util.normalize_headers({ "Request-ID" => nil }))
+                     Util.normalize_headers("Request-ID" => nil))
         assert_equal({ "Request-Id" => nil },
-          Util.normalize_headers({ :request_id => nil }))
+                     Util.normalize_headers(request_id: nil))
       end
 
       should "tolerate bad formatting" do
         assert_equal({ "Request-Id" => nil },
-          Util.normalize_headers({ "-Request--Id-" => nil }))
+                     Util.normalize_headers("-Request--Id-" => nil))
         assert_equal({ "Request-Id" => nil },
-          Util.normalize_headers({ :request__id => nil }))
+                     Util.normalize_headers(request__id: nil))
       end
     end
 
@@ -324,7 +324,7 @@ module Stripe
     context ".colorize" do
       should "colorize for a TTY" do
         assert_equal "\033[0;32;49mfoo\033[0m",
-          Util.send(:colorize, "foo", :green, true)
+                     Util.send(:colorize, "foo", :green, true)
       end
 
       should "not colorize otherwise" do
@@ -348,21 +348,23 @@ module Stripe
         # Open this instance of StringIO, and add a method override so that it
         # looks like a TTY.
         out.instance_eval do
-          def isatty; true; end
+          def isatty
+            true
+          end
         end
 
         Util.send(:log_internal, "message", { foo: "bar" },
-          color: :green, level: Stripe::LEVEL_DEBUG, logger: nil, out: out)
+                  color: :green, level: Stripe::LEVEL_DEBUG, logger: nil, out: out)
         assert_equal "\e[0;32;49mDEBU\e[0m message \e[0;32;49mfoo\e[0m=bar\n",
-          out.string
+                     out.string
       end
 
       should "log in a data friendly way" do
         out = StringIO.new
         Util.send(:log_internal, "message", { foo: "bar" },
-          color: :green, level: Stripe::LEVEL_DEBUG, logger: nil, out: out)
+                  color: :green, level: Stripe::LEVEL_DEBUG, logger: nil, out: out)
         assert_equal "message=message level=debug foo=bar\n",
-          out.string
+                     out.string
       end
 
       should "log to a logger if set" do
@@ -376,9 +378,9 @@ module Stripe
         }
 
         Util.send(:log_internal, "message", { foo: "bar" },
-          color: :green, level: Stripe::LEVEL_DEBUG, logger: logger, out: nil)
+                  color: :green, level: Stripe::LEVEL_DEBUG, logger: logger, out: nil)
         assert_equal "message=message foo=bar",
-          out.string
+                     out.string
       end
     end
 
@@ -395,15 +397,15 @@ module Stripe
       end
 
       should "wrap more complex values in double quotes" do
-        assert_equal %{"abc=123"}, Util.send(:wrap_logfmt_value, %{abc=123})
+        assert_equal %("abc=123"), Util.send(:wrap_logfmt_value, %(abc=123))
       end
 
       should "escape double quotes already in the value" do
-        assert_equal %{"abc=\\"123\\""}, Util.send(:wrap_logfmt_value, %{abc="123"})
+        assert_equal %("abc=\\"123\\""), Util.send(:wrap_logfmt_value, %(abc="123"))
       end
 
       should "remove newlines" do
-        assert_equal %{"abc"}, Util.send(:wrap_logfmt_value, "a\nb\nc")
+        assert_equal %("abc"), Util.send(:wrap_logfmt_value, "a\nb\nc")
       end
 
       should "not error if given a non-string" do