stripe 5.30.0 → 5.31.0

data/lib/stripe/stripe_configuration.rb

@@ -101,14 +101,22 @@ module Stripe
       @max_network_retries = val.to_i
     end
 
+    def max_network_retry_delay=(val)
+      @max_network_retry_delay = val.to_i
+    end
+
+    def initial_network_retry_delay=(val)
+      @initial_network_retry_delay = val.to_i
+    end
+
     def open_timeout=(open_timeout)
       @open_timeout = open_timeout
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def read_timeout=(read_timeout)
       @read_timeout = read_timeout
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def write_timeout=(write_timeout)
@@ -117,32 +125,32 @@ module Stripe
       end
 
       @write_timeout = write_timeout
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def proxy=(proxy)
       @proxy = proxy
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def verify_ssl_certs=(verify_ssl_certs)
       @verify_ssl_certs = verify_ssl_certs
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def uploads_base=(uploads_base)
       @uploads_base = uploads_base
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def connect_base=(connect_base)
       @connect_base = connect_base
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def api_base=(api_base)
       @api_base = api_base
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     def ca_bundle_path=(path)
@@ -151,7 +159,7 @@ module Stripe
       # empty this field so a new store is initialized
       @ca_store = nil
 
-      StripeClient.clear_all_connection_managers
+      StripeClient.clear_all_connection_managers(config: self)
     end
 
     # A certificate store initialized from the the bundle in #ca_bundle_path and
@@ -174,5 +182,13 @@ module Stripe
     def enable_telemetry?
       enable_telemetry
     end
+
+    # Generates a deterministic key to identify configuration objects with
+    # identical configuration values.
+    def key
+      instance_variables
+        .collect { |variable| instance_variable_get(variable) }
+        .join
+    end
   end
 end

data/lib/stripe/stripe_object.rb

@@ -267,6 +267,27 @@ module Stripe
       []
     end
 
+    # When designing APIs, we now make a conscious effort server-side to avoid
+    # naming fields after important built-ins in various languages (e.g. class,
+    # method, etc.).
+    #
+    # However, a long time ago we made the mistake (either consciously or by
+    # accident) of initializing our `metadata` fields as instances of
+    # `StripeObject`, and metadata can have a wide range of different keys
+    # defined in it. This is somewhat a convenient in that it allows users to
+    # access data like `obj.metadata.my_field`, but is almost certainly not
+    # worth the cost.
+    #
+    # Naming metadata fields bad things like `class` causes `initialize_from`
+    # to produce strange results, so we ban known offenders here.
+    #
+    # In a future major version we should consider leaving `metadata` as a hash
+    # and forcing people to access it with `obj.metadata[:my_field]` because
+    # the potential for trouble is just too high. For now, reserve names.
+    RESERVED_FIELD_NAMES = [
+      :class,
+    ].freeze
+
     protected def metaclass
       class << self; self; end
     end
@@ -277,6 +298,7 @@ module Stripe
 
       metaclass.instance_eval do
         keys.each do |k|
+          next if RESERVED_FIELD_NAMES.include?(k)
           next if protected_fields.include?(k)
           next if @@permanent_attributes.include?(k)
 
@@ -312,6 +334,7 @@ module Stripe
 
       metaclass.instance_eval do
         keys.each do |k|
+          next if RESERVED_FIELD_NAMES.include?(k)
           next if protected_fields.include?(k)
           next if @@permanent_attributes.include?(k)
 

data/lib/stripe/util.rb

@@ -76,24 +76,30 @@ module Stripe
     end
 
     def self.log_error(message, data = {})
-      if !Stripe.logger.nil? ||
-         !Stripe.log_level.nil? && Stripe.log_level <= Stripe::LEVEL_ERROR
+      config = data.delete(:config) || Stripe.config
+      logger = config.logger || Stripe.logger
+      if !logger.nil? ||
+         !config.log_level.nil? && config.log_level <= Stripe::LEVEL_ERROR
         log_internal(message, data, color: :cyan, level: Stripe::LEVEL_ERROR,
                                     logger: Stripe.logger, out: $stderr)
       end
     end
 
     def self.log_info(message, data = {})
-      if !Stripe.logger.nil? ||
-         !Stripe.log_level.nil? && Stripe.log_level <= Stripe::LEVEL_INFO
+      config = data.delete(:config) || Stripe.config
+      logger = config.logger || Stripe.logger
+      if !logger.nil? ||
+         !config.log_level.nil? && config.log_level <= Stripe::LEVEL_INFO
         log_internal(message, data, color: :cyan, level: Stripe::LEVEL_INFO,
                                     logger: Stripe.logger, out: $stdout)
       end
     end
 
     def self.log_debug(message, data = {})
-      if !Stripe.logger.nil? ||
-         !Stripe.log_level.nil? && Stripe.log_level <= Stripe::LEVEL_DEBUG
+      config = data.delete(:config) || Stripe.config
+      logger = config.logger || Stripe.logger
+      if !logger.nil? ||
+         !config.log_level.nil? && config.log_level <= Stripe::LEVEL_DEBUG
         log_internal(message, data, color: :blue, level: Stripe::LEVEL_DEBUG,
                                     logger: Stripe.logger, out: $stdout)
       end

data/lib/stripe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stripe
-  VERSION = "5.30.0"
+  VERSION = "5.31.0"
 end

data/test/stripe/connection_manager_test.rb

@@ -79,6 +79,49 @@ module Stripe
         end
       end
 
+      context "when a StripeClient has different configurations" do
+        should "correctly initialize a connection" do
+          old_proxy = Stripe.proxy
+
+          old_open_timeout = Stripe.open_timeout
+          old_read_timeout = Stripe.read_timeout
+
+          begin
+            client = StripeClient.new(
+              proxy: "http://other:pass@localhost:8080",
+              open_timeout: 400,
+              read_timeout: 500,
+              verify_ssl_certs: true
+            )
+            conn = Stripe::ConnectionManager.new(client.config)
+                                            .connection_for("https://stripe.com")
+
+            # Host/port
+            assert_equal "stripe.com", conn.address
+            assert_equal 443, conn.port
+
+            # Proxy
+            assert_equal "localhost", conn.proxy_address
+            assert_equal 8080, conn.proxy_port
+            assert_equal "other", conn.proxy_user
+            assert_equal "pass", conn.proxy_pass
+
+            # Timeouts
+            assert_equal 400, conn.open_timeout
+            assert_equal 500, conn.read_timeout
+
+            assert_equal true, conn.use_ssl?
+            assert_equal OpenSSL::SSL::VERIFY_PEER, conn.verify_mode
+            assert_equal Stripe.ca_store, conn.cert_store
+          ensure
+            Stripe.proxy = old_proxy
+
+            Stripe.open_timeout = old_open_timeout
+            Stripe.read_timeout = old_read_timeout
+          end
+        end
+      end
+
       should "produce the same connection multiple times" do
         conn1 = @manager.connection_for("https://stripe.com")
         conn2 = @manager.connection_for("https://stripe.com")

data/test/stripe/oauth_test.rb

@@ -44,6 +44,14 @@ module Stripe
         assert_equal("connect.stripe.com", uri.host)
         assert_equal("/express/oauth/authorize", uri.path)
       end
+
+      should "override the api base path when a StripeClient is provided" do
+        client = Stripe::StripeClient.new(connect_base: "https://other.stripe.com")
+        uri_str = OAuth.authorize_url({}, client: client)
+
+        uri = URI.parse(uri_str)
+        assert_equal("other.stripe.com", uri.host)
+      end
     end
 
     context ".token" do
@@ -83,6 +91,29 @@ module Stripe
                            code: "this_is_an_authorization_code")
         assert_equal("another_access_token", resp.access_token)
       end
+
+      should "override the api base path when a StripeClient is provided" do
+        stub_request(:post, "https://other.stripe.com/oauth/token")
+          .with(body: {
+            "grant_type" => "authorization_code",
+            "code" => "this_is_an_authorization_code",
+          })
+          .to_return(body: JSON.generate(access_token: "sk_access_token",
+                                         scope: "read_only",
+                                         livemode: false,
+                                         token_type: "bearer",
+                                         refresh_token: "sk_refresh_token",
+                                         stripe_user_id: "acct_test",
+                                         stripe_publishable_key: "pk_test"))
+
+        client = Stripe::StripeClient.new(connect_base: "https://other.stripe.com")
+        resp = OAuth.token(
+          { grant_type: "authorization_code", code: "this_is_an_authorization_code" },
+          client: client
+        )
+
+        assert_equal("sk_access_token", resp.access_token)
+      end
     end
 
     context ".deauthorize" do
@@ -99,6 +130,20 @@ module Stripe
         resp = OAuth.deauthorize(stripe_user_id: "acct_test_deauth")
         assert_equal("acct_test_deauth", resp.stripe_user_id)
       end
+
+      should "override the api base path when a StripeClient is provided" do
+        stub_request(:post, "https://other.stripe.com/oauth/deauthorize")
+          .with(body: {
+            "client_id" => "ca_test",
+            "stripe_user_id" => "acct_test_deauth",
+          })
+          .to_return(body: JSON.generate(stripe_user_id: "acct_test_deauth"))
+
+        client = Stripe::StripeClient.new(connect_base: "https://other.stripe.com")
+        resp = OAuth.deauthorize({ stripe_user_id: "acct_test_deauth" }, client: client)
+
+        assert_equal("acct_test_deauth", resp.stripe_user_id)
+      end
     end
   end
 end

data/test/stripe/stripe_client_test.rb

@@ -4,6 +4,30 @@ require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class StripeClientTest < Test::Unit::TestCase
+    context "initializing a StripeClient" do
+      should "allow a String to be passed in order to set the api key" do
+        assert_equal StripeClient.new("test_123").config.api_key, "test_123"
+      end
+
+      should "allow for overrides via a Hash" do
+        config = { api_key: "test_123", open_timeout: 100 }
+        client = StripeClient.new(config)
+
+        assert_equal client.config.api_key, "test_123"
+        assert_equal client.config.open_timeout, 100
+      end
+
+      should "support deprecated ConnectionManager objects" do
+        assert StripeClient.new(Stripe::ConnectionManager.new).config.is_a?(Stripe::StripeConfiguration)
+      end
+
+      should "support passing a full configuration object" do
+        config = Stripe.config.reverse_duplicate_merge({ api_key: "test_123", open_timeout: 100 })
+        client = StripeClient.new(config)
+        assert_equal config, client.config
+      end
+    end
+
     context ".active_client" do
       should "be .default_client outside of #request" do
         assert_equal StripeClient.default_client, StripeClient.active_client
@@ -82,8 +106,64 @@ module Stripe
         assert_equal 1, StripeClient.maybe_gc_connection_managers
 
         # And as an additional check, the connection manager of the current
-        # thread context should have been set to `nil` as it was GCed.
-        assert_nil StripeClient.current_thread_context.default_connection_manager
+        # thread context should have been removed as it was GCed.
+        assert_equal({}, StripeClient.current_thread_context.default_connection_managers)
+      end
+
+      should "only garbage collect when all connection managers for a thread are expired" do
+        stub_request(:post, "#{Stripe.api_base}/v1/path")
+          .to_return(body: JSON.generate(object: "account"))
+
+        # Make sure we start with a blank slate (state may have been left in
+        # place by other tests).
+        StripeClient.clear_all_connection_managers
+
+        # Establish a base time.
+        t = 0.0
+
+        # And pretend that `StripeClient` was just initialized for the first
+        # time. (Don't access instance variables like this, but it's tricky to
+        # test properly otherwise.)
+        StripeClient.instance_variable_set(:@last_connection_manager_gc, t)
+
+        #
+        # t
+        #
+        Util.stubs(:monotonic_time).returns(t)
+
+        # Execute an initial request to ensure that a connection manager was
+        # created.
+        client = StripeClient.new
+        client.execute_request(:post, "/v1/path")
+
+        # Create a new client with a unique config to make sure the thread has two
+        # connection managers
+        active_client = StripeClient.new(max_network_retries: 10)
+        active_client.execute_request(:post, "/v1/path")
+
+        assert_equal 2, StripeClient.current_thread_context.default_connection_managers.keys.count
+        assert_equal nil, StripeClient.maybe_gc_connection_managers
+
+        # t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1
+        #
+        # Move us far enough into the future that we're passed the horizons for
+        # both a GC run as well as well as the expiry age of a connection
+        # manager. That means the GC will run and collect the connection
+        # manager that we created above.
+        #
+        Util.stubs(:monotonic_time).returns(t + StripeClient::CONNECTION_MANAGER_GC_LAST_USED_EXPIRY + 1)
+
+        # Manually set the active_client's last_used time into the future to prevent GC.
+        StripeClient.default_connection_manager(active_client.config)
+                    .instance_variable_set(:@last_used, Util.monotonic_time + 1)
+
+        assert_equal 0, StripeClient.maybe_gc_connection_managers
+
+        # Move time into the future past the last GC round
+        current_time = Util.monotonic_time
+        Util.stubs(:monotonic_time).returns(current_time * 2)
+
+        assert_equal 1, StripeClient.maybe_gc_connection_managers
       end
     end
 
@@ -129,6 +209,27 @@ module Stripe
         # And finally, give all threads time to perform their check.
         threads.each(&:join)
       end
+
+      should "clear only connection managers with a given configuration" do
+        StripeClient.clear_all_connection_managers
+
+        client1 = StripeClient.new(read_timeout: 5.0)
+        StripeClient.default_connection_manager(client1.config)
+        client2 = StripeClient.new(read_timeout: 2.0)
+        StripeClient.default_connection_manager(client2.config)
+
+        thread_contexts = StripeClient.instance_variable_get(:@thread_contexts_with_connection_managers)
+        assert_equal 1, thread_contexts.count
+        thread_context = thread_contexts.first
+
+        refute_nil thread_context.default_connection_managers[client1.config.key]
+        refute_nil thread_context.default_connection_managers[client2.config.key]
+
+        StripeClient.clear_all_connection_managers(config: client1.config)
+
+        assert_nil thread_context.default_connection_managers[client1.config.key]
+        refute_nil thread_context.default_connection_managers[client2.config.key]
+      end
     end
 
     context ".default_client" do
@@ -160,11 +261,28 @@ module Stripe
         thread.join
         refute_equal StripeClient.default_connection_manager, other_thread_manager
       end
+
+      should "create a separate connection manager per configuration" do
+        config = Stripe::StripeConfiguration.setup { |c| c.open_timeout = 100 }
+        connection_manager_one = StripeClient.default_connection_manager
+        connection_manager_two = StripeClient.default_connection_manager(config)
+
+        assert_equal connection_manager_one.config.open_timeout, 30
+        assert_equal connection_manager_two.config.open_timeout, 100
+      end
+
+      should "create a single connection manager for identical configurations" do
+        StripeClient.clear_all_connection_managers
+
+        2.times { StripeClient.default_connection_manager(Stripe::StripeConfiguration.setup) }
+
+        assert_equal 1, StripeClient.instance_variable_get(:@thread_contexts_with_connection_managers).first.default_connection_managers.size
+      end
     end
 
     context ".should_retry?" do
       setup do
-        Stripe.stubs(:max_network_retries).returns(2)
+        Stripe::StripeConfiguration.any_instance.stubs(:max_network_retries).returns(2)
       end
 
       should "retry on Errno::ECONNREFUSED" do
@@ -275,7 +393,7 @@ module Stripe
     context ".sleep_time" do
       should "should grow exponentially" do
         StripeClient.stubs(:rand).returns(1)
-        Stripe.stubs(:max_network_retry_delay).returns(999)
+        Stripe.config.stubs(:max_network_retry_delay).returns(999)
         assert_equal(Stripe.initial_network_retry_delay, StripeClient.sleep_time(1))
         assert_equal(Stripe.initial_network_retry_delay * 2, StripeClient.sleep_time(2))
         assert_equal(Stripe.initial_network_retry_delay * 4, StripeClient.sleep_time(3))
@@ -284,8 +402,8 @@ module Stripe
 
       should "enforce the max_network_retry_delay" do
         StripeClient.stubs(:rand).returns(1)
-        Stripe.stubs(:initial_network_retry_delay).returns(1)
-        Stripe.stubs(:max_network_retry_delay).returns(2)
+        Stripe.config.stubs(:initial_network_retry_delay).returns(1)
+        Stripe.config.stubs(:max_network_retry_delay).returns(2)
         assert_equal(1, StripeClient.sleep_time(1))
         assert_equal(2, StripeClient.sleep_time(2))
         assert_equal(2, StripeClient.sleep_time(3))
@@ -295,8 +413,8 @@ module Stripe
       should "add some randomness" do
         random_value = 0.8
         StripeClient.stubs(:rand).returns(random_value)
-        Stripe.stubs(:initial_network_retry_delay).returns(1)
-        Stripe.stubs(:max_network_retry_delay).returns(8)
+        Stripe.config.stubs(:initial_network_retry_delay).returns(1)
+        Stripe.config.stubs(:max_network_retry_delay).returns(8)
 
         base_value = Stripe.initial_network_retry_delay * (0.5 * (1 + random_value))
 
@@ -309,6 +427,23 @@ module Stripe
         assert_equal(base_value * 4, StripeClient.sleep_time(3))
         assert_equal(base_value * 8, StripeClient.sleep_time(4))
       end
+
+      should "permit passing in a configuration object" do
+        StripeClient.stubs(:rand).returns(1)
+        config = Stripe::StripeConfiguration.setup do |c|
+          c.initial_network_retry_delay = 1
+          c.max_network_retry_delay = 2
+        end
+
+        # Set the global configuration to be different than the client
+        Stripe.config.stubs(:initial_network_retry_delay).returns(100)
+        Stripe.config.stubs(:max_network_retry_delay).returns(200)
+
+        assert_equal(1, StripeClient.sleep_time(1, config: config))
+        assert_equal(2, StripeClient.sleep_time(2, config: config))
+        assert_equal(2, StripeClient.sleep_time(3, config: config))
+        assert_equal(2, StripeClient.sleep_time(4, config: config))
+      end
     end
 
     context "#execute_request" do
@@ -342,6 +477,10 @@ module Stripe
           # switch over to rspec-mocks at some point, we can probably remove
           # this.
           Util.stubs(:monotonic_time).returns(0.0)
+
+          # Stub the Stripe.config so that mocha matchers will succeed. Currently,
+          # mocha does not support using param matchers within hashes.
+          StripeClient.any_instance.stubs(:config).returns(Stripe.config)
         end
 
         should "produce appropriate logging" do
@@ -353,11 +492,13 @@ module Stripe
                                        idempotency_key: "abc",
                                        method: :post,
                                        num_retries: 0,
-                                       path: "/v1/account")
+                                       path: "/v1/account",
+                                       config: Stripe.config)
           Util.expects(:log_debug).with("Request details",
                                         body: "",
                                         idempotency_key: "abc",
-                                        query: nil)
+                                        query: nil,
+                                        config: Stripe.config)
 
           Util.expects(:log_info).with("Response from Stripe API",
                                        account: "acct_123",
@@ -367,15 +508,18 @@ module Stripe
                                        method: :post,
                                        path: "/v1/account",
                                        request_id: "req_123",
-                                       status: 200)
+                                       status: 200,
+                                       config: Stripe.config)
           Util.expects(:log_debug).with("Response details",
                                         body: body,
                                         idempotency_key: "abc",
-                                        request_id: "req_123")
+                                        request_id: "req_123",
+                                        config: Stripe.config)
           Util.expects(:log_debug).with("Dashboard link for request",
                                         idempotency_key: "abc",
                                         request_id: "req_123",
-                                        url: Util.request_id_dashboard_url("req_123", Stripe.api_key))
+                                        url: Util.request_id_dashboard_url("req_123", Stripe.api_key),
+                                        config: Stripe.config)
 
           stub_request(:post, "#{Stripe.api_base}/v1/account")
             .to_return(
@@ -404,7 +548,8 @@ module Stripe
                                        idempotency_key: nil,
                                        method: :post,
                                        num_retries: 0,
-                                       path: "/v1/account")
+                                       path: "/v1/account",
+                                       config: Stripe.config)
           Util.expects(:log_info).with("Response from Stripe API",
                                        account: nil,
                                        api_version: nil,
@@ -413,7 +558,8 @@ module Stripe
                                        method: :post,
                                        path: "/v1/account",
                                        request_id: nil,
-                                       status: 500)
+                                       status: 500,
+                                       config: Stripe.config)
 
           error = {
             code: "code",
@@ -428,7 +574,8 @@ module Stripe
                                         error_param: error[:param],
                                         error_type: error[:type],
                                         idempotency_key: nil,
-                                        request_id: nil)
+                                        request_id: nil,
+                                        config: Stripe.config)
 
           stub_request(:post, "#{Stripe.api_base}/v1/account")
             .to_return(
@@ -449,7 +596,8 @@ module Stripe
                                        idempotency_key: nil,
                                        method: :post,
                                        num_retries: 0,
-                                       path: "/oauth/token")
+                                       path: "/oauth/token",
+                                       config: Stripe.config)
           Util.expects(:log_info).with("Response from Stripe API",
                                        account: nil,
                                        api_version: nil,
@@ -458,14 +606,16 @@ module Stripe
                                        method: :post,
                                        path: "/oauth/token",
                                        request_id: nil,
-                                       status: 400)
+                                       status: 400,
+                                       config: Stripe.config)
 
           Util.expects(:log_error).with("Stripe OAuth error",
                                         status: 400,
                                         error_code: "invalid_request",
                                         error_description: "No grant type specified",
                                         idempotency_key: nil,
-                                        request_id: nil)
+                                        request_id: nil,
+                                        config: Stripe.config)
 
           stub_request(:post, "#{Stripe.connect_base}/oauth/token")
             .to_return(body: JSON.generate(error: "invalid_request",
@@ -788,7 +938,7 @@ module Stripe
 
       context "idempotency keys" do
         setup do
-          Stripe.stubs(:max_network_retries).returns(2)
+          Stripe::StripeConfiguration.any_instance.stubs(:max_network_retries).returns(2)
         end
 
         should "not add an idempotency key to GET requests" do
@@ -838,7 +988,7 @@ module Stripe
 
       context "retry logic" do
         setup do
-          Stripe.stubs(:max_network_retries).returns(2)
+          Stripe::StripeConfiguration.any_instance.stubs(:max_network_retries).returns(2)
         end
 
         should "retry failed requests and raise if error persists" do
@@ -870,6 +1020,21 @@ module Stripe
           client = StripeClient.new
           client.execute_request(:post, "/v1/charges")
         end
+
+        should "pass the client configuration when retrying" do
+          StripeClient.expects(:sleep_time)
+                      .with(any_of(1, 2),
+                            has_entry(:config, kind_of(Stripe::StripeConfiguration)))
+                      .at_least_once.returns(0)
+
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_raise(Errno::ECONNREFUSED.new)
+
+          client = StripeClient.new
+          assert_raises Stripe::APIConnectionError do
+            client.execute_request(:post, "/v1/charges")
+          end
+        end
       end
 
       context "params serialization" do
@@ -1079,7 +1244,7 @@ module Stripe
     context "#proxy" do
       should "run the request through the proxy" do
         begin
-          StripeClient.current_thread_context.default_connection_manager = nil
+          StripeClient.clear_all_connection_managers
 
           Stripe.proxy = "http://user:pass@localhost:8080"
 
@@ -1095,7 +1260,7 @@ module Stripe
         ensure
           Stripe.proxy = nil
 
-          StripeClient.current_thread_context.default_connection_manager = nil
+          StripeClient.clear_all_connection_managers
         end
       end
     end