stripe 4.20.0 → 5.0.0

data/test/stripe/stripe_client_test.rb

@@ -17,6 +17,50 @@ module Stripe
       end
     end
 
+    context ".clear_all_connection_managers" do
+      should "clear connection managers across all threads" do
+        stub_request(:post, "#{Stripe.api_base}/path")
+          .to_return(body: JSON.generate(object: "account"))
+
+        num_threads = 3
+
+        # Poorly named class -- note this is actually a concurrent queue.
+        recv_queue = Queue.new
+        send_queue = Queue.new
+
+        threads = num_threads.times.map do |_|
+          Thread.start do
+            # Causes a connection manager to be created on this thread and a
+            # connection within that manager to be created for API access.
+            manager = StripeClient.default_connection_manager
+            manager.execute_request(:post, "#{Stripe.api_base}/path")
+
+            # Signal to the main thread we're ready.
+            recv_queue << true
+
+            # Wait for the main thread to signal continue.
+            send_queue.pop
+
+            # This check isn't great, but it's otherwise difficult to tell that
+            # anything happened with just the public-facing API.
+            assert_equal({}, manager.instance_variable_get(:@active_connections))
+          end
+        end
+
+        # Wait for threads to start up.
+        threads.each { recv_queue.pop }
+
+        # Do the clear (the method we're actually trying to test).
+        StripeClient.clear_all_connection_managers
+
+        # Tell threads to run their check.
+        threads.each { send_queue << true }
+
+        # And finally, give all threads time to perform their check.
+        threads.each(&:join)
+      end
+    end
+
     context ".default_client" do
       should "be a StripeClient" do
         assert_kind_of StripeClient, StripeClient.default_client
@@ -32,18 +76,19 @@ module Stripe
       end
     end
 
-    context ".default_conn" do
-      should "be a Faraday::Connection" do
-        assert_kind_of Faraday::Connection, StripeClient.default_conn
+    context ".default_connection_manager" do
+      should "be a ConnectionManager" do
+        assert_kind_of ConnectionManager,
+                       StripeClient.default_connection_manager
       end
 
       should "be a different connection on each thread" do
-        other_thread_conn = nil
+        other_thread_manager = nil
         thread = Thread.new do
-          other_thread_conn = StripeClient.default_conn
+          other_thread_manager = StripeClient.default_connection_manager
         end
         thread.join
-        refute_equal StripeClient.default_conn, other_thread_conn
+        refute_equal StripeClient.default_connection_manager, other_thread_manager
       end
     end
 
@@ -52,26 +97,54 @@ module Stripe
         Stripe.stubs(:max_network_retries).returns(2)
       end
 
-      should "retry on timeout" do
-        assert StripeClient.should_retry?(Faraday::TimeoutError.new(""), 0)
+      should "retry on Errno::ECONNREFUSED" do
+        assert StripeClient.should_retry?(Errno::ECONNREFUSED.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Net::OpenTimeout" do
+        assert StripeClient.should_retry?(Net::OpenTimeout.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on Net::ReadTimeout" do
+        assert StripeClient.should_retry?(Net::ReadTimeout.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on SocketError" do
+        assert StripeClient.should_retry?(SocketError.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "retry on a 409 Conflict" do
+        assert StripeClient.should_retry?(Stripe::StripeError.new(http_status: 409),
+                                          method: :post, num_retries: 0)
       end
 
-      should "retry on a failed connection" do
-        assert StripeClient.should_retry?(Faraday::ConnectionFailed.new(""), 0)
+      should "retry on a 500 Internal Server Error when non-POST" do
+        assert StripeClient.should_retry?(Stripe::StripeError.new(http_status: 500),
+                                          method: :get, num_retries: 0)
       end
 
-      should "retry on a conflict" do
-        error = make_rate_limit_error
-        e = Faraday::ClientError.new(error[:error][:message], status: 409)
-        assert StripeClient.should_retry?(e, 0)
+      should "retry on a 503 Service Unavailable" do
+        assert StripeClient.should_retry?(Stripe::StripeError.new(http_status: 503),
+                                          method: :post, num_retries: 0)
       end
 
       should "not retry at maximum count" do
-        refute StripeClient.should_retry?(RuntimeError.new, Stripe.max_network_retries)
+        refute StripeClient.should_retry?(RuntimeError.new,
+                                          method: :post, num_retries: Stripe.max_network_retries)
       end
 
       should "not retry on a certificate validation error" do
-        refute StripeClient.should_retry?(Faraday::SSLError.new(""), 0)
+        refute StripeClient.should_retry?(OpenSSL::SSL::SSLError.new,
+                                          method: :post, num_retries: 0)
+      end
+
+      should "not retry on a 500 Internal Server Error when POST" do
+        refute StripeClient.should_retry?(Stripe::StripeError.new(http_status: 500),
+                                          method: :post, num_retries: 0)
       end
     end
 
@@ -115,15 +188,16 @@ module Stripe
     end
 
     context "#initialize" do
-      should "set Stripe.default_conn" do
+      should "set Stripe.default_connection_manager" do
         client = StripeClient.new
-        assert_equal StripeClient.default_conn, client.conn
+        assert_equal StripeClient.default_connection_manager,
+                     client.connection_manager
       end
 
       should "set a different connection if one was specified" do
-        conn = Faraday.new
-        client = StripeClient.new(conn)
-        assert_equal conn, client.conn
+        connection_manager = ConnectionManager.new
+        client = StripeClient.new(connection_manager)
+        assert_equal connection_manager, client.connection_manager
       end
     end
 
@@ -178,7 +252,7 @@ module Stripe
           Util.expects(:log_debug).with("Request details",
                                         body: "",
                                         idempotency_key: "abc",
-                                        query_params: nil)
+                                        query: nil)
 
           Util.expects(:log_info).with("Response from Stripe API",
                                        account: "acct_123",
@@ -403,6 +477,20 @@ module Stripe
           assert_equal 'Invalid response object from API: "" (HTTP response code was 200)', e.message
         end
 
+        should "handle low level error" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_raise(Errno::ECONNREFUSED.new)
+
+          client = StripeClient.new
+          e = assert_raises Stripe::APIConnectionError do
+            client.execute_request(:post, "/v1/charges")
+          end
+
+          assert_equal StripeClient::ERROR_MESSAGE_CONNECTION % Stripe.api_base +
+                       "\n\n(Network error: Connection refused)",
+                       e.message
+        end
+
         should "handle error response with unknown value" do
           stub_request(:post, "#{Stripe.api_base}/v1/charges")
             .to_return(body: JSON.generate(bar: "foo"), status: 500)
@@ -738,14 +826,106 @@ module Stripe
 
       should "reset local thread state after a call" do
         begin
-          Thread.current[:stripe_client] = :stripe_client
+          StripeClient.current_thread_context.active_client = :stripe_client
 
           client = StripeClient.new
           client.request {}
 
-          assert_equal :stripe_client, Thread.current[:stripe_client]
+          assert_equal :stripe_client,
+                       StripeClient.current_thread_context.active_client
         ensure
-          Thread.current[:stripe_client] = nil
+          StripeClient.current_thread_context.active_client = nil
+        end
+      end
+
+      should "correctly return last responses despite multiple clients" do
+        charge_resp = { object: "charge" }
+        coupon_resp = { object: "coupon" }
+
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(charge_resp))
+        stub_request(:post, "#{Stripe.api_base}/v1/coupons")
+          .to_return(body: JSON.generate(coupon_resp))
+
+        client1 = StripeClient.new
+        client2 = StripeClient.new
+
+        client2_resp = nil
+        _charge, client1_resp = client1.request do
+          Charge.create
+
+          # This is contrived, but we run one client nested in the `request`
+          # block of another one just to ensure that the parent is still
+          # unwinding when this goes through. If the parent's last response
+          # were to be overridden by this client (through a bug), then it would
+          # happen here.
+          _coupon, client2_resp = client2.request do
+            Coupon.create
+          end
+        end
+
+        assert_equal charge_resp, client1_resp.data
+        assert_equal coupon_resp, client2_resp.data
+      end
+
+      should "correctly return last responses despite multiple threads" do
+        charge_resp = { object: "charge" }
+        coupon_resp = { object: "coupon" }
+
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(charge_resp))
+        stub_request(:post, "#{Stripe.api_base}/v1/coupons")
+          .to_return(body: JSON.generate(coupon_resp))
+
+        client = StripeClient.new
+
+        # Poorly named class -- note this is actually a concurrent queue.
+        recv_queue = Queue.new
+        send_queue = Queue.new
+
+        # Start a thread, make an API request, but then idle in the `request`
+        # block until the main thread has been able to make its own API request
+        # and signal that it's done. If this thread's last response were to be
+        # overridden by the main thread (through a bug), then this routine
+        # should suss it out.
+        resp1 = nil
+        thread = Thread.start do
+          _charge, resp1 = client.request do
+            Charge.create
+
+            # Idle in `request` block until main thread signals.
+            send_queue.pop
+          end
+
+          # Signal main thread that we're done and it can run its checks.
+          recv_queue << true
+        end
+
+        # Make an API request.
+        _coupon, resp2 = client.request do
+          Coupon.create
+        end
+
+        # Tell background thread to finish `request`, then wait for it to
+        # signal back to us that it's ready.
+        send_queue << true
+        recv_queue.pop
+
+        assert_equal charge_resp, resp1.data
+        assert_equal coupon_resp, resp2.data
+
+        # And for maximum hygiene, make sure that our thread rejoins.
+        thread.join
+      end
+
+      should "error if calls to #request are nested on the same thread" do
+        client = StripeClient.new
+        client.request do
+          e = assert_raises(RuntimeError) do
+            client.request {}
+          end
+          assert_equal "calls to StripeClient#request cannot be nested within a thread",
+                       e.message
         end
       end
     end
@@ -753,18 +933,23 @@ module Stripe
     context "#proxy" do
       should "run the request through the proxy" do
         begin
-          Thread.current[:stripe_client_default_conn] = nil
+          StripeClient.current_thread_context.default_connection_manager = nil
 
-          Stripe.proxy = "http://localhost:8080"
+          Stripe.proxy = "http://user:pass@localhost:8080"
 
           client = StripeClient.new
           client.request {}
 
-          assert_equal "http://localhost:8080", Stripe::StripeClient.default_conn.proxy.uri.to_s
+          connection = Stripe::StripeClient.default_connection_manager.connection_for(Stripe.api_base)
+
+          assert_equal "localhost", connection.proxy_address
+          assert_equal 8080, connection.proxy_port
+          assert_equal "user", connection.proxy_user
+          assert_equal "pass", connection.proxy_pass
         ensure
           Stripe.proxy = nil
 
-          Thread.current[:stripe_client_default_conn] = nil
+          StripeClient.current_thread_context.default_connection_manager = nil
         end
       end
     end

data/test/stripe/stripe_object_test.rb

@@ -52,9 +52,9 @@ module Stripe
             2,
           ],
           map: {
-            :"0" => StripeObject.construct_from({ id: "index0" }, opts),
-            :"1" => "index1",
-            :"2" => 2,
+            "0": StripeObject.construct_from({ id: "index0" }, opts),
+            "1": "index1",
+            "2": 2,
           },
         }
 
@@ -235,20 +235,6 @@ module Stripe
       assert_equal true, obj.send(:metaclass).method_defined?(:foo)
     end
 
-    should "warn that #refresh_from is deprecated" do
-      old_stderr = $stderr
-      $stderr = StringIO.new
-      begin
-        obj = Stripe::StripeObject.construct_from({})
-        obj.refresh_from({}, {})
-        message = "NOTE: Stripe::StripeObject#refresh_from is " \
-                  "deprecated; use #update_attributes instead"
-        assert_match Regexp.new(message), $stderr.string
-      ensure
-        $stderr = old_stderr
-      end
-    end
-
     should "pass opts down to children when initializing" do
       opts = { custom: "opts" }
 
@@ -302,14 +288,14 @@ module Stripe
     end
 
     should "#serialize_params on an array that shortens" do
-      obj = Stripe::StripeObject.construct_from(foo: ["0-index", "1-index", "2-index"])
+      obj = Stripe::StripeObject.construct_from(foo: %w[0-index 1-index 2-index])
       obj.foo = ["new-value"]
       assert_equal({ foo: ["new-value"] },
                    obj.serialize_params)
     end
 
     should "#serialize_params on an array that lengthens" do
-      obj = Stripe::StripeObject.construct_from(foo: ["0-index", "1-index", "2-index"])
+      obj = Stripe::StripeObject.construct_from(foo: %w[0-index 1-index 2-index])
       obj.foo = ["new-value"] * 4
       assert_equal({ foo: ["new-value"] * 4 },
                    obj.serialize_params)
@@ -331,8 +317,8 @@ module Stripe
     end
 
     should "#serialize_params on an array that is unchanged" do
-      obj = Stripe::StripeObject.construct_from(foo: ["0-index", "1-index", "2-index"])
-      obj.foo = ["0-index", "1-index", "2-index"]
+      obj = Stripe::StripeObject.construct_from(foo: %w[0-index 1-index 2-index])
+      obj.foo = %w[0-index 1-index 2-index]
       assert_equal({}, obj.serialize_params)
     end
 
@@ -475,20 +461,6 @@ module Stripe
       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

data/test/stripe/stripe_response_test.rb

@@ -4,46 +4,92 @@ require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class StripeResponseTest < Test::Unit::TestCase
-    context ".from_faraday_hash" do
-      should "converts to StripeResponse" do
-        body = '{"foo": "bar"}'
+    context "Headers" do
+      should "allow case-insensitive header access" do
         headers = { "Request-Id" => "request-id" }
+        http_resp = create_net_http_resp(200, "", headers)
 
-        http_resp = {
-          body: body,
-          headers: headers,
-          status: 200,
-        }
+        headers = StripeResponse::Headers.from_net_http(http_resp)
 
-        resp = StripeResponse.from_faraday_hash(http_resp)
+        assert_equal "request-id", headers["request-id"]
+        assert_equal "request-id", headers["Request-Id"]
+        assert_equal "request-id", headers["Request-ID"]
+      end
 
-        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
+      should "initialize without error" do
+        StripeResponse::Headers.new({})
+        StripeResponse::Headers.new("Request-Id" => [])
+        StripeResponse::Headers.new("Request-Id" => ["request-id"])
+      end
+
+      should "initialize with error on a malformed hash" do
+        assert_raises(ArgumentError) do
+          StripeResponse::Headers.new(nil)
+        end
+
+        assert_raises(ArgumentError) do
+          StripeResponse::Headers.new(1 => [])
+        end
+
+        assert_raises(ArgumentError) do
+          StripeResponse::Headers.new("Request-Id" => 1)
+        end
+
+        assert_raises(ArgumentError) do
+          StripeResponse::Headers.new("Request-Id" => [1])
+        end
+      end
+
+      should "warn on duplicate header values" do
+        old_stderr = $stderr
+        $stderr = StringIO.new
+        begin
+          headers = StripeResponse::Headers.new("Duplicated" => %w[a b])
+          assert_equal "a", headers["Duplicated"]
+          assert_equal "Duplicate header values for `Duplicated`; returning only first",
+                       $stderr.string.rstrip
+        ensure
+          $stderr = old_stderr
+        end
       end
     end
 
-    context ".from_faraday_response" do
+    context ".from_net_http" do
       should "converts to StripeResponse" do
+        code = 200
         body = '{"foo": "bar"}'
         headers = { "Request-Id" => "request-id" }
+        http_resp = create_net_http_resp(code, body, headers)
 
-        env = Faraday::Env.from(
-          status: 200, body: body,
-          response_headers: headers
-        )
-        http_resp = Faraday::Response.new(env)
-
-        resp = StripeResponse.from_faraday_response(http_resp)
+        resp = StripeResponse.from_net_http(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.http_headers["Request-ID"]
+        assert_equal code, resp.http_status
         assert_equal "request-id", resp.request_id
       end
     end
+
+    # Synthesizes a `Net::HTTPResponse` object for testing purposes.
+    private def create_net_http_resp(code, body, headers)
+      # The "1.1" is HTTP version.
+      http_resp = Net::HTTPResponse.new("1.1", code.to_s, nil)
+      http_resp.body = body
+
+      # This is obviously super sketchy, but the Ruby team has done everything
+      # in their power to make these objects as difficult to test with as
+      # possible. Even if you specify a body, accessing `#body` the first time
+      # will attempt to read from a non-existent socket which will subsequently
+      # blow up. Setting this internal variable skips that read and allows the
+      # object to use the body that we specified above.
+      http_resp.instance_variable_set(:@read, true)
+
+      headers.each do |name, value|
+        http_resp[name] = value
+      end
+
+      http_resp
+    end
   end
 end

data/test/stripe/subscription_item_test.rb

@@ -59,5 +59,17 @@ module Stripe
         assert item.is_a?(Stripe::SubscriptionItem)
       end
     end
+
+    context "#create_usage_record" do
+      should "create a usage record" do
+        Stripe::SubscriptionItem.create_usage_record(
+          "si_123",
+          quantity: 5000,
+          timestamp: Time.now.to_i,
+          action: "increment"
+        )
+        assert_requested :post, "#{Stripe.api_base}/v1/subscription_items/si_123/usage_records"
+      end
+    end
   end
 end

data/test/stripe/subscription_schedule_test.rb

@@ -78,39 +78,5 @@ module Stripe
         assert schedule.is_a?(Stripe::SubscriptionSchedule)
       end
     end
-
-    context "#revisions" do
-      should "retrieve the subscription schedule's revisions" do
-        schedule = Stripe::SubscriptionSchedule.retrieve("sub_sched_123")
-        revisions = schedule.revisions
-        assert_requested :get,
-                         "#{Stripe.api_base}/v1/subscription_schedules/sub_sched_123/revisions"
-        assert revisions.data.is_a?(Array)
-        assert revisions.data[0].is_a?(Stripe::SubscriptionScheduleRevision)
-      end
-    end
-
-    context "#retrieve_revision" do
-      should "retrieve a subscription schedule revision" do
-        revision = Stripe::SubscriptionSchedule.retrieve_revision(
-          "sub_sched_123",
-          "sub_sched_rev_123"
-        )
-        assert_requested :get, "#{Stripe.api_base}/v1/subscription_schedules/sub_sched_123/revisions/sub_sched_rev_123"
-        assert revision.is_a?(Stripe::SubscriptionScheduleRevision)
-      end
-    end
-
-    context "#list_revisions" do
-      should "list a subscription schedule's revisions" do
-        revisions = Stripe::SubscriptionSchedule.list_revisions(
-          "sub_sched_123"
-        )
-        assert_requested :get, "#{Stripe.api_base}/v1/subscription_schedules/sub_sched_123/revisions"
-        assert revisions.is_a?(Stripe::ListObject)
-        assert revisions.data.is_a?(Array)
-        assert revisions.data[0].is_a?(Stripe::SubscriptionScheduleRevision)
-      end
-    end
   end
 end

data/test/stripe/subscription_test.rb

@@ -63,9 +63,9 @@ module Stripe
     context "#delete_discount" do
       should "be able to delete a subscriptions's discount" do
         subscription = Stripe::Subscription.retrieve("sub_123")
-        subscription = subscription.delete_discount
+        discount = subscription.delete_discount
         assert_requested :delete, "#{Stripe.api_base}/v1/subscriptions/sub_123/discount"
-        assert subscription.is_a?(Stripe::Subscription)
+        assert discount.is_a?(Stripe::Discount)
       end
     end
 

data/test/stripe/webhook_test.rb

@@ -4,13 +4,13 @@ require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class WebhookTest < Test::Unit::TestCase
-    EVENT_PAYLOAD = <<-PAYLOAD.freeze
+    EVENT_PAYLOAD = <<~PAYLOAD
       {
         "id": "evt_test_webhook",
         "object": "event"
       }
     PAYLOAD
-    SECRET = "whsec_test_secret".freeze
+    SECRET = "whsec_test_secret"
 
     def generate_header(opts = {})
       opts[:timestamp] ||= Time.now.to_i

data/test/stripe_mock.rb

@@ -4,8 +4,8 @@ module Stripe
   class StripeMock
     include Singleton
 
-    PATH_SPEC = "#{::File.dirname(__FILE__)}/openapi/spec3.json".freeze
-    PATH_FIXTURES = "#{::File.dirname(__FILE__)}/openapi/fixtures3.json".freeze
+    PATH_SPEC = "#{::File.dirname(__FILE__)}/openapi/spec3.json"
+    PATH_FIXTURES = "#{::File.dirname(__FILE__)}/openapi/fixtures3.json"
 
     @pid = nil
     @port = -1
@@ -29,7 +29,7 @@ module Stripe
       @stderr, @child_stderr = ::IO.pipe
 
       @pid = ::Process.spawn(
-        ["stripe-mock", "stripe-mock"],
+        %w[stripe-mock stripe-mock],
         "-http-port",
         "0", # have stripe-mock select a port
         "-spec",
@@ -66,6 +66,7 @@ module Stripe
     # Stops stripe-mock, if necessary.
     def self.stop
       return if @pid.nil?
+
       puts("Stopping stripe-mock...")
       ::Process.kill(:SIGTERM, @pid)
       ::Process.waitpid2(@pid)

data/test/stripe_test.rb

@@ -3,19 +3,6 @@
 require ::File.expand_path("test_helper", __dir__)
 
 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