stripe 3.2.0 → 5.16.0

data/test/stripe/topup_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class TopupTest < Test::Unit::TestCase
+    should "be listable" do
+      topups = Stripe::Topup.list
+      assert_requested :get, "#{Stripe.api_base}/v1/topups"
+      assert topups.data.is_a?(Array)
+      assert topups.data[0].is_a?(Stripe::Topup)
+    end
+
+    should "be retrievable" do
+      topup = Stripe::Topup.retrieve("tu_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/topups/tu_123"
+      assert topup.is_a?(Stripe::Topup)
+    end
+
+    should "be creatable" do
+      topup = Stripe::Topup.create(
+        amount: 100,
+        currency: "USD",
+        source: "src_123",
+        description: "description",
+        statement_descriptor: "statement descriptor"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/topups"
+      assert topup.is_a?(Stripe::Topup)
+    end
+
+    should "be saveable" do
+      topup = Stripe::Topup.retrieve("tu_123")
+      topup.metadata["key"] = "value"
+      topup.save
+      assert_requested :post, "#{Stripe.api_base}/v1/topups/#{topup.id}"
+    end
+
+    should "be updateable" do
+      topup = Stripe::Topup.update("tu_123", metadata: { foo: "bar" })
+      assert_requested :post, "#{Stripe.api_base}/v1/topups/tu_123"
+      assert topup.is_a?(Stripe::Topup)
+    end
+
+    context "#cancel" do
+      should "cancel the topup" do
+        topup = Stripe::Topup.retrieve("tu_123")
+        topup = topup.cancel
+        assert_requested :post, "#{Stripe.api_base}/v1/topups/#{topup.id}/cancel"
+        assert topup.is_a?(Stripe::Topup)
+      end
+    end
+
+    context ".cancel" do
+      should "cancel the topup" do
+        topup = Stripe::Topup.cancel("tu_123")
+        assert_requested :post, "#{Stripe.api_base}/v1/topups/tu_123/cancel"
+        assert topup.is_a?(Stripe::Topup)
+      end
+    end
+  end
+end

data/test/stripe/transfer_test.rb

@@ -1,18 +1,20 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 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 +24,65 @@ 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
+
+    context "#create_reversal" do
+      should "create a reversal" do
+        reversal = Stripe::Transfer.create_reversal(
+          "tr_123",
+          amount: 100
+        )
+        assert_requested :post, "#{Stripe.api_base}/v1/transfers/tr_123/reversals"
+        assert reversal.is_a?(Stripe::Reversal)
+      end
+    end
+
+    context "#retrieve_reversal" do
+      should "retrieve a reversal" do
+        reversal = Stripe::Transfer.retrieve_reversal(
+          "tr_123",
+          "trr_123"
+        )
+        assert_requested :get, "#{Stripe.api_base}/v1/transfers/tr_123/reversals/trr_123"
+        assert reversal.is_a?(Stripe::Reversal)
+      end
+    end
+
+    context "#update_reversal" do
+      should "update a reversal" do
+        reversal = Stripe::Transfer.update_reversal(
+          "tr_123",
+          "trr_123",
+          metadata: { foo: "bar" }
+        )
+        assert_requested :post, "#{Stripe.api_base}/v1/transfers/tr_123/reversals/trr_123"
+        assert reversal.is_a?(Stripe::Reversal)
+      end
+    end
+
+    context "#list_reversals" do
+      should "list the transfer's reversals" do
+        reversals = Stripe::Transfer.list_reversals(
+          "tr_123"
+        )
+        assert_requested :get, "#{Stripe.api_base}/v1/transfers/tr_123/reversals"
+        assert reversals.is_a?(Stripe::ListObject)
+        assert reversals.data.is_a?(Array)
+      end
     end
   end
 end

data/test/stripe/usage_record_summary_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class UsageRecordSummaryTest < Test::Unit::TestCase
+    setup do
+      @sub_item = Stripe::SubscriptionItem.retrieve("si_123")
+    end
+
+    should "be listable" do
+      old_stderr = $stderr
+      $stderr = StringIO.new
+
+      begin
+        transactions = @sub_item.usage_record_summaries
+
+        assert_requested :get, "#{Stripe.api_base}/v1/subscription_items/#{@sub_item.id}/usage_record_summaries"
+        assert transactions.data.is_a?(Array)
+        assert transactions.first.is_a?(Stripe::UsageRecordSummary)
+
+        assert_include $stderr.string,
+                       "use SubscriptionItem.list_usage_record_summaries instead"
+      ensure
+        $stderr = old_stderr
+      end
+    end
+  end
+end

data/test/stripe/util_test.rb

@@ -1,53 +1,43 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class UtilTest < Test::Unit::TestCase
+    context "OPTS_COPYABLE" do
+      should "include :apibase" do
+        assert_include Stripe::Util::OPTS_COPYABLE, :api_base
+      end
+    end
+
+    context "OPTS_PERSISTABLE" do
+      should "include :client" do
+        assert_include Stripe::Util::OPTS_PERSISTABLE, :client
+      end
+
+      should "not include :idempotency_key" do
+        refute_includes Stripe::Util::OPTS_PERSISTABLE, :idempotency_key
+      end
+    end
+
     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=",
+        "a=3&b=%2Bfoo%3F&c=bar%26baz&d[a]=a&d[b]=b&e[0]=0&e[1]=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)
@@ -61,50 +51,50 @@ 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"],
         ["d[b]",     "b"],
-        ["e[]",      0],
-        ["e[]",      1],
+        ["e[0]",      0],
+        ["e[1]",      1],
 
         # *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[][foo]", "1"],
-        ["f[][ghi]", "2"],
-        ["f[][foo]", "3"],
-        ["f[][bar]", "4"],
+        ["f[0][foo]", "1"],
+        ["f[0][ghi]", "2"],
+        ["f[1][foo]", "3"],
+        ["f[1][bar]", "4"],
       ], Stripe::Util.flatten_params(params))
     end
 
     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 +103,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 +112,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
 
@@ -142,24 +132,20 @@ module Stripe
       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
-
     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
 
@@ -168,12 +154,16 @@ module Stripe
         @old_log_level = Stripe.log_level
         Stripe.log_level = nil
 
+        @old_stderr = $stderr
+        $stderr = StringIO.new
+
         @old_stdout = $stdout
         $stdout = StringIO.new
       end
 
       teardown do
         Stripe.log_level = @old_log_level
+        $stderr = @old_stderr
         $stdout = @old_stdout
       end
 
@@ -189,6 +179,12 @@ module Stripe
           assert_equal "message=foo level=debug \n", $stdout.string
         end
 
+        should "not log if level set to error" do
+          Stripe.log_level = Stripe::LEVEL_ERROR
+          Util.log_debug("foo")
+          assert_equal "", $stdout.string
+        end
+
         should "not log if level set to info" do
           Stripe.log_level = Stripe::LEVEL_INFO
           Util.log_debug("foo")
@@ -196,6 +192,31 @@ module Stripe
         end
       end
 
+      context ".log_error" do
+        should "not log if logging is disabled" do
+          Util.log_error("foo")
+          assert_equal "", $stdout.string
+        end
+
+        should "log if level set to debug" do
+          Stripe.log_level = Stripe::LEVEL_DEBUG
+          Util.log_error("foo")
+          assert_equal "message=foo level=error \n", $stderr.string
+        end
+
+        should "log if level set to error" do
+          Stripe.log_level = Stripe::LEVEL_ERROR
+          Util.log_error("foo")
+          assert_equal "message=foo level=error \n", $stderr.string
+        end
+
+        should "log if level set to info" do
+          Stripe.log_level = Stripe::LEVEL_INFO
+          Util.log_error("foo")
+          assert_equal "message=foo level=error \n", $stderr.string
+        end
+      end
+
       context ".log_info" do
         should "not log if logging is disabled" do
           Util.log_info("foo")
@@ -208,6 +229,12 @@ module Stripe
           assert_equal "message=foo level=info \n", $stdout.string
         end
 
+        should "not log if level set to error" do
+          Stripe.log_level = Stripe::LEVEL_ERROR
+          Util.log_debug("foo")
+          assert_equal "", $stdout.string
+        end
+
         should "log if level set to info" do
           Stripe.log_level = Stripe::LEVEL_INFO
           Util.log_info("foo")
@@ -216,23 +243,59 @@ module Stripe
       end
     end
 
+    context ".log_* with a logger" do
+      setup do
+        @out = StringIO.new
+        logger = ::Logger.new(@out)
+
+        # Set a really simple formatter to make matching output as easy as
+        # possible.
+        logger.formatter = proc { |_severity, _datetime, _progname, message|
+          message
+        }
+
+        Stripe.logger = logger
+      end
+
+      context ".log_debug" do
+        should "log to the logger" do
+          Util.log_debug("foo")
+          assert_equal "message=foo ", @out.string
+        end
+      end
+
+      context ".log_error" do
+        should "log to the logger" do
+          Util.log_error("foo")
+          assert_equal "message=foo ", @out.string
+        end
+      end
+
+      context ".log_info" do
+        should "log to the logger" do
+          Util.log_info("foo")
+          assert_equal "message=foo ", @out.string
+        end
+      end
+    end
+
     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
 
@@ -247,7 +310,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
@@ -255,6 +318,14 @@ module Stripe
       end
     end
 
+    context ".level_name" do
+      should "convert levels to names" do
+        assert_equal "debug", Util.send(:level_name, LEVEL_DEBUG)
+        assert_equal "error", Util.send(:level_name, LEVEL_ERROR)
+        assert_equal "info", Util.send(:level_name, LEVEL_INFO)
+      end
+    end
+
     context ".log_internal" do
       should "log in a terminal friendly way" do
         out = StringIO.new
@@ -263,21 +334,39 @@ 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, 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, 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
+        out = StringIO.new
+        logger = ::Logger.new(out)
+
+        # Set a really simple formatter to make matching output as easy as
+        # possible.
+        logger.formatter = proc { |_severity, _datetime, _progname, message|
+          message
+        }
+
+        Util.send(:log_internal, "message", { foo: "bar" },
+                  color: :green, level: Stripe::LEVEL_DEBUG, logger: logger, out: $stdout)
+        assert_equal "message=message foo=bar",
+                     out.string
       end
     end
 
@@ -294,15 +383,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

data/test/stripe/webhook_endpoint_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class WebhookEndpointTest < Test::Unit::TestCase
+    should "be listable" do
+      webhook_endpoints = Stripe::WebhookEndpoint.list
+      assert_requested :get, "#{Stripe.api_base}/v1/webhook_endpoints"
+      assert webhook_endpoints.data.is_a?(Array)
+      assert webhook_endpoints.first.is_a?(Stripe::WebhookEndpoint)
+    end
+
+    should "be retrievable" do
+      webhook_endpoint = Stripe::WebhookEndpoint.retrieve("we_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/webhook_endpoints/we_123"
+      assert webhook_endpoint.is_a?(Stripe::WebhookEndpoint)
+    end
+
+    should "be creatable" do
+      webhook_endpoint = Stripe::WebhookEndpoint.create(
+        enabled_events: ["charge.succeeded"],
+        url: "https://stripe.com"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/webhook_endpoints"
+      assert webhook_endpoint.is_a?(Stripe::WebhookEndpoint)
+    end
+
+    should "be saveable" do
+      webhook_endpoint = Stripe::WebhookEndpoint.retrieve("we_123")
+      webhook_endpoint.enabled_events = ["charge.succeeded"]
+      webhook_endpoint.save
+      assert_requested :post, "#{Stripe.api_base}/v1/webhook_endpoints/#{webhook_endpoint.id}"
+    end
+
+    should "be updateable" do
+      webhook_endpoint = Stripe::WebhookEndpoint.update("we_123", enabled_events: ["charge.succeeded"])
+      assert_requested :post, "#{Stripe.api_base}/v1/webhook_endpoints/we_123"
+      assert webhook_endpoint.is_a?(Stripe::WebhookEndpoint)
+    end
+
+    context "#delete" do
+      should "be deletable" do
+        webhook_endpoint = Stripe::WebhookEndpoint.retrieve("we_123")
+        webhook_endpoint = webhook_endpoint.delete
+        assert_requested :delete, "#{Stripe.api_base}/v1/webhook_endpoints/#{webhook_endpoint.id}"
+        assert webhook_endpoint.is_a?(Stripe::WebhookEndpoint)
+      end
+    end
+
+    context ".delete" do
+      should "be deletable" do
+        webhook_endpoint = Stripe::WebhookEndpoint.delete("we_123")
+        assert_requested :delete, "#{Stripe.api_base}/v1/webhook_endpoints/we_123"
+        assert webhook_endpoint.is_a?(Stripe::WebhookEndpoint)
+      end
+    end
+  end
+end