stripe 4.10.0 → 5.55.0

data/test/stripe/util_test.rb

@@ -1,402 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __FILE__)
-
-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: "",
-
-        # note the empty hash won't even show up in the request
-        g: [],
-      }
-      assert_equal(
-        "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 "#url_encode should prepare strings for HTTP" do
-      assert_equal "foo",      Stripe::Util.url_encode("foo")
-      assert_equal "foo",      Stripe::Util.url_encode(:foo)
-      assert_equal "foo%2B",   Stripe::Util.url_encode("foo+")
-      assert_equal "foo%26",   Stripe::Util.url_encode("foo&")
-      assert_equal "foo[bar]", Stripe::Util.url_encode("foo[bar]")
-    end
-
-    should "#flatten_params should encode parameters according to Rails convention" do
-      params = [
-        [:a, 3],
-        [:b, "foo?"],
-        [:c, "bar&baz"],
-        [:d, { a: "a", b: "b" }],
-        [:e, [0, 1]],
-        [:f, [
-          { foo: "1", ghi: "2" },
-          { foo: "3", bar: "4" },
-        ],],
-      ]
-      assert_equal([
-        ["a", 3],
-        ["b",        "foo?"],
-        ["c",        "bar&baz"],
-        ["d[a]",     "a"],
-        ["d[b]",     "b"],
-        ["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[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" => {
-          1 => 2,
-          :symbol => 9,
-          "string" => nil,
-        },
-      }
-      finish = {
-        foo: "bar",
-        array: [{ foo: "bar" }],
-        nested: {
-          1 => 2,
-          :symbol => 9,
-          :string => nil,
-        },
-      }
-
-      symbolized = Stripe::Util.symbolize_names(start)
-      assert_equal(finish, symbolized)
-    end
-
-    should "#normalize_opts should reject nil keys" do
-      assert_raise { Stripe::Util.normalize_opts(nil) }
-      assert_raise { Stripe::Util.normalize_opts(api_key: nil) }
-    end
-
-    should "#convert_to_stripe_object should pass through unknown types" do
-      obj = Util.convert_to_stripe_object(7, {})
-      assert_equal 7, obj
-    end
-
-    should "#convert_to_stripe_object should turn hashes into StripeObjects" do
-      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" }, {})
-      assert obj.is_a?(ListObject)
-    end
-
-    should "#convert_to_stripe_object should marshal other classes" do
-      obj = Util.convert_to_stripe_object({ object: "account" }, {})
-      assert obj.is_a?(Account)
-    end
-
-    should "#convert_to_stripe_object should marshal arrays" do
-      obj = Util.convert_to_stripe_object([1, 2, 3], {})
-      assert_equal [1, 2, 3], obj
-    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")
-      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")
-      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)
-      end
-    end
-
-    context ".log_*" do
-      setup do
-        @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
-
-      context ".log_debug" do
-        should "not log if logging is disabled" do
-          Util.log_debug("foo")
-          assert_equal "", $stdout.string
-        end
-
-        should "log if level set to debug" do
-          Stripe.log_level = Stripe::LEVEL_DEBUG
-          Util.log_debug("foo")
-          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")
-          assert_equal "", $stdout.string
-        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")
-          assert_equal "", $stdout.string
-        end
-
-        should "log if level set to debug" do
-          Stripe.log_level = Stripe::LEVEL_DEBUG
-          Util.log_info("foo")
-          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")
-          assert_equal "message=foo level=info \n", $stdout.string
-        end
-      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))
-        assert_equal({ "Request-Id" => nil },
-                     Util.normalize_headers("request-id" => nil))
-        assert_equal({ "Request-Id" => nil },
-                     Util.normalize_headers("Request-ID" => nil))
-        assert_equal({ "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))
-        assert_equal({ "Request-Id" => nil },
-                     Util.normalize_headers(request__id: nil))
-      end
-    end
-
-    #
-    # private
-    #
-    # I don't feel particularly good about using #send to invoke these, but I
-    # want them hidden from the public interface, and each method is far easier
-    # to test in isolation (as opposed to going through a public method).
-    #
-
-    context ".colorize" do
-      should "colorize for a TTY" do
-        assert_equal "\033[0;32;49mfoo\033[0m",
-                     Util.send(:colorize, "foo", :green, true)
-      end
-
-      should "not colorize otherwise" do
-        assert_equal "foo", Util.send(:colorize, "foo", :green, false)
-      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
-
-        # Sketchy as anything, but saves us from pulling in a mocking library.
-        # 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
-        end
-
-        Util.send(:log_internal, "message", { foo: "bar" },
-                  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
-      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)
-        assert_equal "message=message level=debug foo=bar\n",
-                     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
-
-    context ".wrap_logfmt_value" do
-      should "pass through simple values" do
-        assert_equal "abc", Util.send(:wrap_logfmt_value, "abc")
-        assert_equal "123", Util.send(:wrap_logfmt_value, "123")
-        assert_equal "a-b_c/d", Util.send(:wrap_logfmt_value, "a-b_c/d")
-      end
-
-      should "pass through numerics" do
-        assert_equal 123, Util.send(:wrap_logfmt_value, 123)
-        assert_equal 1.23, Util.send(:wrap_logfmt_value, 1.23)
-      end
-
-      should "wrap more complex values in double quotes" do
-        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"))
-      end
-
-      should "remove newlines" do
-        assert_equal %("abc"), Util.send(:wrap_logfmt_value, "a\nb\nc")
-      end
-
-      should "not error if given a non-string" do
-        assert_equal "true", Util.send(:wrap_logfmt_value, true)
-      end
-    end
-  end
-end

data/test/stripe/webhook_endpoint_test.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __FILE__)
-
-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
-  end
-end

data/test/stripe/webhook_test.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __FILE__)
-
-module Stripe
-  class WebhookTest < Test::Unit::TestCase
-    EVENT_PAYLOAD = <<-PAYLOAD.freeze
-      {
-        "id": "evt_test_webhook",
-        "object": "event"
-      }
-    PAYLOAD
-    SECRET = "whsec_test_secret".freeze
-
-    def generate_header(opts = {})
-      opts[:timestamp] ||= Time.now.to_i
-      opts[:payload] ||= EVENT_PAYLOAD
-      opts[:secret] ||= SECRET
-      opts[:scheme] ||= Stripe::Webhook::Signature::EXPECTED_SCHEME
-      opts[:signature] ||= Stripe::Webhook::Signature.send(:compute_signature, "#{opts[:timestamp]}.#{opts[:payload]}", opts[:secret])
-      "t=#{opts[:timestamp]},#{opts[:scheme]}=#{opts[:signature]}"
-    end
-
-    context ".construct_event" do
-      should "return an Event instance from a valid JSON payload and valid signature header" do
-        header = generate_header
-        event = Stripe::Webhook.construct_event(EVENT_PAYLOAD, header, SECRET)
-        assert event.is_a?(Stripe::Event)
-      end
-
-      should "raise a JSON::ParserError from an invalid JSON payload" do
-        assert_raises JSON::ParserError do
-          payload = "this is not valid JSON"
-          header = generate_header(payload: payload)
-          Stripe::Webhook.construct_event(payload, header, SECRET)
-        end
-      end
-
-      should "raise a SignatureVerificationError from a valid JSON payload and an invalid signature header" do
-        header = "bad_header"
-        assert_raises Stripe::SignatureVerificationError do
-          Stripe::Webhook.construct_event(EVENT_PAYLOAD, header, SECRET)
-        end
-      end
-    end
-
-    context ".verify_signature_header" do
-      should "raise a SignatureVerificationError when the header does not have the expected format" do
-        header = 'i\'m not even a real signature header'
-        e = assert_raises(Stripe::SignatureVerificationError) do
-          Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, "secret")
-        end
-        assert_match("Unable to extract timestamp and signatures from header", e.message)
-      end
-
-      should "raise a SignatureVerificationError when there are no signatures with the expected scheme" do
-        header = generate_header(scheme: "v0")
-        e = assert_raises(Stripe::SignatureVerificationError) do
-          Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, "secret")
-        end
-        assert_match("No signatures found with expected scheme", e.message)
-      end
-
-      should "raise a SignatureVerificationError when there are no valid signatures for the payload" do
-        header = generate_header(signature: "bad_signature")
-        e = assert_raises(Stripe::SignatureVerificationError) do
-          Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, "secret")
-        end
-        assert_match("No signatures found matching the expected signature for payload", e.message)
-      end
-
-      should "raise a SignatureVerificationError when the timestamp is not within the tolerance" do
-        header = generate_header(timestamp: Time.now.to_i - 15)
-        e = assert_raises(Stripe::SignatureVerificationError) do
-          Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, SECRET, tolerance: 10)
-        end
-        assert_match("Timestamp outside the tolerance zone", e.message)
-      end
-
-      should "return true when the header contains a valid signature and the timestamp is within the tolerance" do
-        header = generate_header
-        assert(Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, SECRET, tolerance: 10))
-      end
-
-      should "return true when the header contains at least one valid signature" do
-        header = generate_header + ",v1=bad_signature"
-        assert(Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, SECRET, tolerance: 10))
-      end
-
-      should "return true when the header contains a valid signature and the timestamp is off but no tolerance is provided" do
-        header = generate_header(timestamp: 12_345)
-        assert(Stripe::Webhook::Signature.verify_header(EVENT_PAYLOAD, header, SECRET))
-      end
-    end
-  end
-end

data/test/stripe_mock.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module Stripe
-  class StripeMock
-    include Singleton
-
-    PATH_SPEC = "#{::File.dirname(__FILE__)}/openapi/spec3.json".freeze
-    PATH_FIXTURES = "#{::File.dirname(__FILE__)}/openapi/fixtures3.json".freeze
-
-    @pid = nil
-    @port = -1
-
-    # Starts stripe-mock, if necessary. Returns the port on which stripe-mock is listening.
-    def self.start
-      unless ::File.exist?(PATH_SPEC)
-        port = ENV["STRIPE_MOCK_PORT"] || 12_111
-        puts("No custom spec file found, assuming stripe-mock is already running on port #{port}")
-        return port
-      end
-
-      unless @pid.nil?
-        puts("stripe-mock already running on port #{@port}")
-        return @port
-      end
-
-      puts("Starting stripe-mock...")
-
-      @stdout, @child_stdout = ::IO.pipe
-      @stderr, @child_stderr = ::IO.pipe
-
-      @pid = ::Process.spawn(
-        ["stripe-mock", "stripe-mock"],
-        "-http-port",
-        "0", # have stripe-mock select a port
-        "-spec",
-        PATH_SPEC,
-        "-fixtures",
-        PATH_FIXTURES,
-        out: @child_stdout,
-        err: @child_stderr
-      )
-
-      [@child_stdout, @child_stderr].each(&:close)
-
-      # Look for port in "Listening for HTTP on port: 50602"
-      buffer = ""
-      loop do
-        buffer += @stdout.readpartial(4096)
-        if (matches = buffer.match(/ port: (\d+)/))
-          @port = matches[1]
-          break
-        end
-        sleep(0.1)
-      end
-
-      status = (::Process.wait2(@pid, ::Process::WNOHANG) || []).last
-      if status.nil?
-        puts("Started stripe-mock; PID = #{@pid}, port = #{@port}")
-      else
-        abort("stripe-mock terminated early: #{status}")
-      end
-
-      @port
-    end
-
-    # Stops stripe-mock, if necessary.
-    def self.stop
-      return if @pid.nil?
-      puts("Stopping stripe-mock...")
-      ::Process.kill(:SIGTERM, @pid)
-      ::Process.waitpid2(@pid)
-      @pid = nil
-      @port = -1
-      puts("Stopped stripe-mock")
-    end
-  end
-end

data/test/stripe_test.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../test_helper", __FILE__)
-
-class StripeTest < Test::Unit::TestCase
-  should "warn that #refresh_from is deprecated" do
-    old_stderr = $stderr
-    $stderr = StringIO.new
-    begin
-      Stripe.uri_encode({})
-      message = "NOTE: Stripe.uri_encode is deprecated; use " \
-                "Stripe::Util#encode_parameters instead"
-      assert_match Regexp.new(message), $stderr.string
-    ensure
-      $stderr = old_stderr
-    end
-  end
-
-  should "allow app_info to be configured" do
-    begin
-      old = Stripe.app_info
-      Stripe.set_app_info(
-        "MyAwesomePlugin",
-        partner_id: "partner_1234",
-        url: "https://myawesomeplugin.info",
-        version: "1.2.34"
-      )
-      assert_equal({
-        name: "MyAwesomePlugin",
-        partner_id: "partner_1234",
-        url: "https://myawesomeplugin.info",
-        version: "1.2.34",
-      }, Stripe.app_info)
-    ensure
-      Stripe.app_info = old
-    end
-  end
-
-  should "allow ca_bundle_path to be configured" do
-    begin
-      old = Stripe.ca_bundle_path
-      Stripe.ca_bundle_path = "path/to/ca/bundle"
-      assert_equal "path/to/ca/bundle", Stripe.ca_bundle_path
-    ensure
-      Stripe.ca_bundle_path = old
-    end
-  end
-
-  should "allow max_network_retries to be configured" do
-    begin
-      old = Stripe.max_network_retries
-      Stripe.max_network_retries = 99
-      assert_equal 99, Stripe.max_network_retries
-    ensure
-      Stripe.max_network_retries = old
-    end
-  end
-
-  should "have default open and read timeouts" do
-    assert_equal Stripe.open_timeout, 30
-    assert_equal Stripe.read_timeout, 80
-  end
-end