bongloy 4.21.3

data/test/stripe/reporting/report_type_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../../test_helper", __dir__)
+
+module Stripe
+  module Reporting
+    class ReportTypeTest < Test::Unit::TestCase
+      should "be listable" do
+        report_types = Stripe::Reporting::ReportType.list
+        assert_requested :get, "#{Stripe.api_base}/v1/reporting/report_types"
+        assert report_types.data.is_a?(Array)
+        assert report_types.data[0].is_a?(Stripe::Reporting::ReportType)
+      end
+
+      should "be retrievable" do
+        report_type = Stripe::Reporting::ReportType.retrieve("activity.summary.1")
+        assert_requested :get, "#{Stripe.api_base}/v1/reporting/report_types/activity.summary.1"
+        assert report_type.is_a?(Stripe::Reporting::ReportType)
+      end
+    end
+  end
+end

data/test/stripe/reversal_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class ReversalTest < Test::Unit::TestCase
+    setup do
+      @transfer = Stripe::Transfer.retrieve("tr_123")
+    end
+
+    should "be listable" do
+      reversals = @transfer.reversals.list
+      assert_requested :get,
+                       "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals"
+      assert reversals.data.is_a?(Array)
+      assert reversals.data[0].is_a?(Stripe::Reversal)
+    end
+
+    should "be retrievable" do
+      reversal = @transfer.reversals.retrieve("trr_123")
+      assert_requested :get,
+                       "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals/trr_123"
+      assert reversal.is_a?(Stripe::Reversal)
+    end
+
+    should "be creatable" do
+      reversal = @transfer.reversals.create(
+        amount: 100
+      )
+      assert_requested :post,
+                       "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals"
+      assert reversal.is_a?(Stripe::Reversal)
+    end
+
+    should "be saveable" do
+      reversal = @transfer.reversals.retrieve("trr_123")
+      reversal.metadata["key"] = "value"
+      reversal.save
+      assert_requested :post,
+                       "#{Stripe.api_base}/v1/transfers/#{reversal.transfer}/reversals/#{reversal.id}"
+    end
+  end
+end

data/test/stripe/review_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class ReviewTest < Test::Unit::TestCase
+    should "be listable" do
+      reviews = Stripe::Review.list
+      assert_requested :get, "#{Stripe.api_base}/v1/reviews"
+      assert reviews.data.is_a?(Array)
+      assert reviews.first.is_a?(Stripe::Review)
+    end
+
+    should "be retrievable" do
+      review = Stripe::Review.retrieve("prv_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/reviews/prv_123"
+      assert review.is_a?(Stripe::Review)
+    end
+
+    should "be approvable" do
+      review = Stripe::Review.retrieve("prv_123")
+      review.approve
+      assert_requested :post, "#{Stripe.api_base}/v1/reviews/prv_123/approve"
+      assert review.is_a?(Stripe::Review)
+    end
+  end
+end

data/test/stripe/setup_intent_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class SetupIntentTest < Test::Unit::TestCase
+    TEST_RESOURCE_ID = "seti_123".freeze
+
+    should "be listable" do
+      setup_intents = Stripe::SetupIntent.list
+      assert_requested :get, "#{Stripe.api_base}/v1/setup_intents"
+      assert setup_intents.data.is_a?(Array)
+      assert setup_intents.data[0].is_a?(Stripe::SetupIntent)
+    end
+
+    should "be retrievable" do
+      setup_intent = Stripe::SetupIntent.retrieve("seti_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/setup_intents/seti_123"
+      assert setup_intent.is_a?(Stripe::SetupIntent)
+    end
+
+    should "be creatable" do
+      setup_intent = Stripe::SetupIntent.create(
+        payment_method_types: ["card"]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/setup_intents"
+      assert setup_intent.is_a?(Stripe::SetupIntent)
+    end
+
+    should "be saveable" do
+      setup_intent = Stripe::SetupIntent.construct_from(id: "seti_123", object: "setup_intent", metadata: {})
+      setup_intent.metadata["key"] = "value"
+      setup_intent.save
+      assert_requested :post, "#{Stripe.api_base}/v1/setup_intents/#{setup_intent.id}"
+    end
+
+    should "be updateable" do
+      setup_intent = Stripe::SetupIntent.update("seti_123", metadata: { foo: "bar" })
+
+      assert_requested :post, "#{Stripe.api_base}/v1/setup_intents/seti_123"
+      assert setup_intent.is_a?(Stripe::SetupIntent)
+    end
+
+    context "#cancel" do
+      should "cancel a setup_intent" do
+        setup_intent = Stripe::SetupIntent.construct_from(id: "seti_123", object: "setup_intent")
+        setup_intent = setup_intent.cancel
+
+        assert_requested :post, "#{Stripe.api_base}/v1/setup_intents/seti_123/cancel"
+        assert setup_intent.is_a?(Stripe::SetupIntent)
+      end
+    end
+
+    context ".cancel" do
+      should "cancel a setup_intent" do
+        setup_intent = Stripe::SetupIntent.cancel("seti_123")
+
+        assert_requested :post, "#{Stripe.api_base}/v1/setup_intents/seti_123/cancel"
+        assert setup_intent.is_a?(Stripe::SetupIntent)
+      end
+    end
+
+    context "#confirm" do
+      should "confirm a setup_intent" do
+        setup_intent = Stripe::SetupIntent.construct_from(id: "seti_123", object: "setup_intent")
+        setup_intent = setup_intent.confirm(
+          payment_method: "pm_123"
+        )
+
+        assert_requested :post, "#{Stripe.api_base}/v1/setup_intents/seti_123/confirm"
+        assert setup_intent.is_a?(Stripe::SetupIntent)
+      end
+    end
+
+    context ".confirm" do
+      should "confirm a setup_intent" do
+        setup_intent = Stripe::SetupIntent.confirm("seti_123", payment_method: "pm_123")
+
+        assert_requested :post, "#{Stripe.api_base}/v1/setup_intents/seti_123/confirm"
+        assert setup_intent.is_a?(Stripe::SetupIntent)
+      end
+    end
+  end
+end

data/test/stripe/sigma/scheduled_query_run_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../../test_helper", __dir__)
+
+module Stripe
+  module Issuing
+    class ScheduledQueryRunTest < Test::Unit::TestCase
+      should "be listable" do
+        runs = Stripe::Sigma::ScheduledQueryRun.list
+        assert_requested :get, "#{Stripe.api_base}/v1/sigma/scheduled_query_runs"
+        assert runs.data.is_a?(Array)
+        assert runs.data[0].is_a?(Stripe::Sigma::ScheduledQueryRun)
+      end
+
+      should "be retrievable" do
+        run = Stripe::Sigma::ScheduledQueryRun.retrieve("sqr_123")
+        assert_requested :get, "#{Stripe.api_base}/v1/sigma/scheduled_query_runs/sqr_123"
+        assert run.is_a?(Stripe::Sigma::ScheduledQueryRun)
+      end
+    end
+  end
+end

data/test/stripe/sku_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class SKUTest < Test::Unit::TestCase
+    should "be listable" do
+      skus = Stripe::SKU.list
+      assert_requested :get, "#{Stripe.api_base}/v1/skus"
+      assert skus.data.is_a?(Array)
+      assert skus.data[0].is_a?(Stripe::SKU)
+    end
+
+    should "be retrievable" do
+      sku = Stripe::SKU.retrieve("sku_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/skus/sku_123"
+      assert sku.is_a?(Stripe::SKU)
+    end
+
+    should "be creatable" do
+      _ = Stripe::SKU.create(
+        currency: "USD",
+        inventory: { type: "finite", quantity: 500 },
+        price: 100,
+        product: "prod_123"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/skus"
+    end
+
+    should "be saveable" do
+      sku = Stripe::SKU.retrieve("sku_123")
+      sku.metadata["key"] = "value"
+      sku.save
+      assert_requested :post, "#{Stripe.api_base}/v1/skus/#{sku.id}"
+    end
+
+    should "be updateable" do
+      sku = Stripe::SKU.update("sku_123", metadata: { foo: "bar" })
+      assert_requested :post, "#{Stripe.api_base}/v1/skus/sku_123"
+      assert sku.is_a?(Stripe::SKU)
+    end
+
+    context "#delete" do
+      should "be deletable" do
+        sku = Stripe::SKU.retrieve("sku_123")
+        sku = sku.delete
+        assert_requested :delete, "#{Stripe.api_base}/v1/skus/#{sku.id}"
+        assert sku.is_a?(Stripe::SKU)
+      end
+    end
+
+    context ".delete" do
+      should "be deletable" do
+        sku = Stripe::SKU.delete("sku_123")
+        assert_requested :delete, "#{Stripe.api_base}/v1/skus/sku_123"
+        assert sku.is_a?(Stripe::SKU)
+      end
+    end
+  end
+end

data/test/stripe/source_test.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class SourceTest < Test::Unit::TestCase
+    should "be retrievable" do
+      source = Stripe::Source.retrieve("src_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/sources/src_123"
+      assert source.is_a?(Stripe::Source)
+    end
+
+    should "be creatable" do
+      source = Stripe::Source.create(
+        type: "card",
+        token: "tok_123"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/sources"
+      assert source.is_a?(Stripe::Source)
+    end
+
+    should "be saveable" do
+      source = Stripe::Source.retrieve("src_123")
+      source.metadata["key"] = "value"
+      source.save
+      assert_requested :post, "#{Stripe.api_base}/v1/sources/#{source.id}"
+    end
+
+    should "be updateable" do
+      source = Stripe::Source.update("src_123", metadata: { foo: "bar" })
+      assert_requested :post, "#{Stripe.api_base}/v1/sources/src_123"
+      assert source.is_a?(Stripe::Source)
+    end
+
+    context "#detach" do
+      should "not be deletable when unattached" do
+        source = Stripe::Source.retrieve("src_123")
+
+        assert_raises NotImplementedError do
+          source.detach
+        end
+      end
+
+      should "be deletable when attached to a customer" do
+        source = Stripe::Source.construct_from(customer: "cus_123",
+                                               id: "src_123",
+                                               object: "source")
+        source = source.detach
+        assert_requested :delete, "#{Stripe.api_base}/v1/customers/cus_123/sources/src_123"
+        assert source.is_a?(Stripe::Source)
+      end
+    end
+
+    context "#delete" do
+      should "warn that #delete is deprecated" do
+        old_stderr = $stderr
+        $stderr = StringIO.new
+        begin
+          source = Stripe::Source.construct_from(customer: "cus_123",
+                                                 id: "src_123",
+                                                 object: "source")
+          source.delete
+          message = "NOTE: Stripe::Source#delete is " \
+                    "deprecated; use #detach instead"
+          assert_match Regexp.new(message), $stderr.string
+        ensure
+          $stderr = old_stderr
+        end
+      end
+    end
+
+    should "not be listable" do
+      assert_raises NoMethodError do
+        Stripe::Source.list
+      end
+    end
+
+    context "#verify" do
+      should "verify the source" do
+        source = Stripe::Source.retrieve("src_123")
+        source = source.verify(values: [1, 2])
+        assert_requested :post,
+                         "#{Stripe.api_base}/v1/sources/#{source.id}/verify",
+                         body: { values: [1, 2] }
+        assert source.is_a?(Stripe::Source)
+      end
+    end
+
+    context ".verify" do
+      should "verify the source" do
+        source = Stripe::Source.verify("src_123", values: [1, 2])
+        assert_requested :post,
+                         "#{Stripe.api_base}/v1/sources/src_123/verify",
+                         body: { values: [1, 2] }
+        assert source.is_a?(Stripe::Source)
+      end
+    end
+  end
+end

data/test/stripe/source_transaction_test.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class SourceTransactionTest < Test::Unit::TestCase
+    setup do
+      @source = Stripe::Source.retrieve("src_123")
+    end
+
+    should "be listable" do
+      transactions = @source.source_transactions
+
+      assert_requested :get, "#{Stripe.api_base}/v1/sources/#{@source.id}/source_transactions"
+      assert transactions.data.is_a?(Array)
+      assert transactions.first.is_a?(Stripe::SourceTransaction)
+    end
+  end
+end

data/test/stripe/stripe_client_test.rb

@@ -0,0 +1,842 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class StripeClientTest < Test::Unit::TestCase
+    context ".active_client" do
+      should "be .default_client outside of #request" do
+        assert_equal StripeClient.default_client, StripeClient.active_client
+      end
+
+      should "be active client inside of #request" do
+        client = StripeClient.new
+        client.request do
+          assert_equal client, StripeClient.active_client
+        end
+      end
+    end
+
+    context ".default_client" do
+      should "be a StripeClient" do
+        assert_kind_of StripeClient, StripeClient.default_client
+      end
+
+      should "be a different client on each thread" do
+        other_thread_client = nil
+        thread = Thread.new do
+          other_thread_client = StripeClient.default_client
+        end
+        thread.join
+        refute_equal StripeClient.default_client, other_thread_client
+      end
+    end
+
+    context ".default_conn" do
+      should "be a Faraday::Connection" do
+        assert_kind_of Faraday::Connection, StripeClient.default_conn
+      end
+
+      should "be a different connection on each thread" do
+        other_thread_conn = nil
+        thread = Thread.new do
+          other_thread_conn = StripeClient.default_conn
+        end
+        thread.join
+        refute_equal StripeClient.default_conn, other_thread_conn
+      end
+    end
+
+    context ".should_retry?" do
+      setup do
+        Stripe.stubs(:max_network_retries).returns(2)
+      end
+
+      should "retry on timeout" do
+        assert StripeClient.should_retry?(Faraday::TimeoutError.new(""), 0)
+      end
+
+      should "retry on a failed connection" do
+        assert StripeClient.should_retry?(Faraday::ConnectionFailed.new(""), 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)
+      end
+
+      should "not retry at maximum count" do
+        refute StripeClient.should_retry?(RuntimeError.new, Stripe.max_network_retries)
+      end
+
+      should "not retry on a certificate validation error" do
+        refute StripeClient.should_retry?(Faraday::SSLError.new(""), 0)
+      end
+    end
+
+    context ".sleep_time" do
+      should "should grow exponentially" do
+        StripeClient.stubs(:rand).returns(1)
+        Stripe.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))
+        assert_equal(Stripe.initial_network_retry_delay * 8, StripeClient.sleep_time(4))
+      end
+
+      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)
+        assert_equal(1, StripeClient.sleep_time(1))
+        assert_equal(2, StripeClient.sleep_time(2))
+        assert_equal(2, StripeClient.sleep_time(3))
+        assert_equal(2, StripeClient.sleep_time(4))
+      end
+
+      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)
+
+        base_value = Stripe.initial_network_retry_delay * (0.5 * (1 + random_value))
+
+        # the initial value cannot be smaller than the base,
+        # so the randomness is ignored
+        assert_equal(Stripe.initial_network_retry_delay, StripeClient.sleep_time(1))
+
+        # after the first one, the randomness is applied
+        assert_equal(base_value * 2, StripeClient.sleep_time(2))
+        assert_equal(base_value * 4, StripeClient.sleep_time(3))
+        assert_equal(base_value * 8, StripeClient.sleep_time(4))
+      end
+    end
+
+    context "#initialize" do
+      should "set Stripe.default_conn" do
+        client = StripeClient.new
+        assert_equal StripeClient.default_conn, client.conn
+      end
+
+      should "set a different connection if one was specified" do
+        conn = Faraday.new
+        client = StripeClient.new(conn)
+        assert_equal conn, client.conn
+      end
+    end
+
+    context "#execute_request" do
+      context "headers" do
+        should "support literal headers" do
+          stub_request(:post, "#{Stripe.api_base}/v1/account")
+            .with(headers: { "Stripe-Account" => "bar" })
+            .to_return(body: JSON.generate(object: "account"))
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/account",
+                                 headers: { "Stripe-Account" => "bar" })
+        end
+
+        should "support RestClient-style header keys" do
+          stub_request(:post, "#{Stripe.api_base}/v1/account")
+            .with(headers: { "Stripe-Account" => "bar" })
+            .to_return(body: JSON.generate(object: "account"))
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/account",
+                                 headers: { stripe_account: "bar" })
+        end
+      end
+
+      context "logging" do
+        setup do
+          # Freeze time for the purposes of the `elapsed` parameter that we
+          # emit for responses. I didn't want to bring in a new dependency for
+          # this, but Mocha's `anything` parameter can't match inside of a hash
+          # and is therefore not useful for this purpose. If we switch over to
+          # rspec-mocks at some point, we can probably remove Timecop from the
+          # project.
+          Timecop.freeze(Time.local(1990))
+        end
+
+        teardown do
+          Timecop.return
+        end
+
+        should "produce appropriate logging" do
+          body = JSON.generate(object: "account")
+
+          Util.expects(:log_info).with("Request to Stripe API",
+                                       account: "acct_123",
+                                       api_version: "2010-11-12",
+                                       idempotency_key: "abc",
+                                       method: :post,
+                                       num_retries: 0,
+                                       path: "/v1/account")
+          Util.expects(:log_debug).with("Request details",
+                                        body: "",
+                                        idempotency_key: "abc",
+                                        query_params: nil)
+
+          Util.expects(:log_info).with("Response from Stripe API",
+                                       account: "acct_123",
+                                       api_version: "2010-11-12",
+                                       elapsed: 0.0,
+                                       idempotency_key: "abc",
+                                       method: :post,
+                                       path: "/v1/account",
+                                       request_id: "req_123",
+                                       status: 200)
+          Util.expects(:log_debug).with("Response details",
+                                        body: body,
+                                        idempotency_key: "abc",
+                                        request_id: "req_123")
+          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))
+
+          stub_request(:post, "#{Stripe.api_base}/v1/account")
+            .to_return(
+              body: body,
+              headers: {
+                "Idempotency-Key" => "abc",
+                "Request-Id" => "req_123",
+                "Stripe-Account" => "acct_123",
+                "Stripe-Version" => "2010-11-12",
+              }
+            )
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/account",
+                                 headers: {
+                                   "Idempotency-Key" => "abc",
+                                   "Stripe-Account" => "acct_123",
+                                   "Stripe-Version" => "2010-11-12",
+                                 })
+        end
+
+        should "produce logging on API error" do
+          Util.expects(:log_info).with("Request to Stripe API",
+                                       account: nil,
+                                       api_version: nil,
+                                       idempotency_key: nil,
+                                       method: :post,
+                                       num_retries: 0,
+                                       path: "/v1/account")
+          Util.expects(:log_info).with("Response from Stripe API",
+                                       account: nil,
+                                       api_version: nil,
+                                       elapsed: 0.0,
+                                       idempotency_key: nil,
+                                       method: :post,
+                                       path: "/v1/account",
+                                       request_id: nil,
+                                       status: 500)
+
+          error = {
+            code: "code",
+            message: "message",
+            param: "param",
+            type: "type",
+          }
+          Util.expects(:log_error).with("Stripe API error",
+                                        status: 500,
+                                        error_code: error[:code],
+                                        error_message: error[:message],
+                                        error_param: error[:param],
+                                        error_type: error[:type],
+                                        idempotency_key: nil,
+                                        request_id: nil)
+
+          stub_request(:post, "#{Stripe.api_base}/v1/account")
+            .to_return(
+              body: JSON.generate(error: error),
+              status: 500
+            )
+
+          client = StripeClient.new
+          assert_raises Stripe::APIError do
+            client.execute_request(:post, "/v1/account")
+          end
+        end
+
+        should "produce logging on OAuth error" do
+          Util.expects(:log_info).with("Request to Stripe API",
+                                       account: nil,
+                                       api_version: nil,
+                                       idempotency_key: nil,
+                                       method: :post,
+                                       num_retries: 0,
+                                       path: "/oauth/token")
+          Util.expects(:log_info).with("Response from Stripe API",
+                                       account: nil,
+                                       api_version: nil,
+                                       elapsed: 0.0,
+                                       idempotency_key: nil,
+                                       method: :post,
+                                       path: "/oauth/token",
+                                       request_id: nil,
+                                       status: 400)
+
+          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)
+
+          stub_request(:post, "#{Stripe.connect_base}/oauth/token")
+            .to_return(body: JSON.generate(error: "invalid_request",
+                                           error_description: "No grant type specified"), status: 400)
+
+          client = StripeClient.new
+          opts = { api_base: Stripe.connect_base }
+          assert_raises Stripe::OAuth::InvalidRequestError do
+            client.execute_request(:post, "/oauth/token", opts)
+          end
+        end
+      end
+
+      context "Stripe-Account header" do
+        should "use a globally set header" do
+          begin
+            old = Stripe.stripe_account
+            Stripe.stripe_account = "acct_1234"
+
+            stub_request(:post, "#{Stripe.api_base}/v1/account")
+              .with(headers: { "Stripe-Account" => Stripe.stripe_account })
+              .to_return(body: JSON.generate(object: "account"))
+
+            client = StripeClient.new
+            client.execute_request(:post, "/v1/account")
+          ensure
+            Stripe.stripe_account = old
+          end
+        end
+
+        should "use a locally set header" do
+          stripe_account = "acct_0000"
+          stub_request(:post, "#{Stripe.api_base}/v1/account")
+            .with(headers: { "Stripe-Account" => stripe_account })
+            .to_return(body: JSON.generate(object: "account"))
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/account",
+                                 headers: { stripe_account: stripe_account })
+        end
+
+        should "not send it otherwise" do
+          stub_request(:post, "#{Stripe.api_base}/v1/account")
+            .with do |req|
+              req.headers["Stripe-Account"].nil?
+            end.to_return(body: JSON.generate(object: "account"))
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/account")
+        end
+      end
+
+      context "app_info" do
+        should "send app_info if set" do
+          begin
+            old = Stripe.app_info
+            Stripe.set_app_info(
+              "MyAwesomePlugin",
+              partner_id: "partner_1234",
+              url: "https://myawesomeplugin.info",
+              version: "1.2.34"
+            )
+
+            stub_request(:post, "#{Stripe.api_base}/v1/account")
+              .with do |req|
+                assert_equal \
+                  "Stripe/v1 RubyBindings/#{Stripe::VERSION} " \
+                  "MyAwesomePlugin/1.2.34 (https://myawesomeplugin.info)",
+                  req.headers["User-Agent"]
+
+                data = JSON.parse(req.headers["X-Stripe-Client-User-Agent"],
+                                  symbolize_names: true)
+
+                assert_equal({
+                  name: "MyAwesomePlugin",
+                  partner_id: "partner_1234",
+                  url: "https://myawesomeplugin.info",
+                  version: "1.2.34",
+                }, data[:application])
+
+                true
+              end.to_return(body: JSON.generate(object: "account"))
+
+            client = StripeClient.new
+            client.execute_request(:post, "/v1/account")
+          ensure
+            Stripe.app_info = old
+          end
+        end
+      end
+
+      context "error handling" do
+        should "handle error response with empty body" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: "", status: 500)
+
+          client = StripeClient.new
+          e = assert_raises Stripe::APIError do
+            client.execute_request(:post, "/v1/charges")
+          end
+
+          assert_equal 'Invalid response object from API: "" (HTTP response code was 500)', e.message
+        end
+
+        should "handle success response with empty body" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: "", status: 200)
+
+          client = StripeClient.new
+          e = assert_raises Stripe::APIError do
+            client.execute_request(:post, "/v1/charges")
+          end
+
+          assert_equal 'Invalid response object from API: "" (HTTP response code was 200)', 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)
+
+          client = StripeClient.new
+          e = assert_raises Stripe::APIError do
+            client.execute_request(:post, "/v1/charges")
+          end
+
+          assert_equal 'Invalid response object from API: "{\"bar\":\"foo\"}" (HTTP response code was 500)', e.message
+        end
+
+        should "raise IdempotencyError on 400 of type idempotency_error" do
+          data = make_missing_id_error
+          data[:error][:type] = "idempotency_error"
+
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(data), status: 400)
+          client = StripeClient.new
+
+          e = assert_raises Stripe::IdempotencyError do
+            client.execute_request(:post, "/v1/charges")
+          end
+          assert_equal(400, e.http_status)
+          assert_equal(true, e.json_body.is_a?(Hash))
+        end
+
+        should "raise InvalidRequestError on other 400s" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_missing_id_error), status: 400)
+          client = StripeClient.new
+          begin
+            client.execute_request(:post, "/v1/charges")
+          rescue Stripe::InvalidRequestError => e
+            assert_equal(400, e.http_status)
+            assert_equal(true, e.json_body.is_a?(Hash))
+          end
+        end
+
+        should "raise AuthenticationError on 401" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_missing_id_error), status: 401)
+          client = StripeClient.new
+          begin
+            client.execute_request(:post, "/v1/charges")
+          rescue Stripe::AuthenticationError => e
+            assert_equal(401, e.http_status)
+            assert_equal(true, e.json_body.is_a?(Hash))
+          end
+        end
+
+        should "raise CardError on 402" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_invalid_exp_year_error), status: 402)
+          client = StripeClient.new
+          begin
+            client.execute_request(:post, "/v1/charges")
+          rescue Stripe::CardError => e
+            assert_equal(402, e.http_status)
+            assert_equal(true, e.json_body.is_a?(Hash))
+            assert_equal("invalid_expiry_year", e.code)
+            assert_equal("exp_year", e.param)
+          end
+        end
+
+        should "raise PermissionError on 403" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_missing_id_error), status: 403)
+          client = StripeClient.new
+          begin
+            client.execute_request(:post, "/v1/charges")
+          rescue Stripe::PermissionError => e
+            assert_equal(403, e.http_status)
+            assert_equal(true, e.json_body.is_a?(Hash))
+          end
+        end
+
+        should "raise InvalidRequestError on 404" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_missing_id_error), status: 404)
+          client = StripeClient.new
+          begin
+            client.execute_request(:post, "/v1/charges")
+          rescue Stripe::InvalidRequestError => e
+            assert_equal(404, e.http_status)
+            assert_equal(true, e.json_body.is_a?(Hash))
+          end
+        end
+
+        should "raise RateLimitError on 429" do
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return(body: JSON.generate(make_rate_limit_error), status: 429)
+          client = StripeClient.new
+          begin
+            client.execute_request(:post, "/v1/charges")
+          rescue Stripe::RateLimitError => e
+            assert_equal(429, e.http_status)
+            assert_equal(true, e.json_body.is_a?(Hash))
+          end
+        end
+
+        should "raise OAuth::InvalidRequestError when error is a string with value 'invalid_request'" do
+          stub_request(:post, "#{Stripe.connect_base}/oauth/token")
+            .to_return(body: JSON.generate(error: "invalid_request",
+                                           error_description: "No grant type specified"), status: 400)
+
+          client = StripeClient.new
+          opts = { api_base: Stripe.connect_base }
+          e = assert_raises Stripe::OAuth::InvalidRequestError do
+            client.execute_request(:post, "/oauth/token", opts)
+          end
+
+          assert_equal(400, e.http_status)
+          assert_equal("No grant type specified", e.message)
+        end
+
+        should "raise OAuth::InvalidGrantError when error is a string with value 'invalid_grant'" do
+          stub_request(:post, "#{Stripe.connect_base}/oauth/token")
+            .to_return(body: JSON.generate(error: "invalid_grant",
+                                           error_description: "This authorization code has already been used. All tokens issued with this code have been revoked."), status: 400)
+
+          client = StripeClient.new
+          opts = { api_base: Stripe.connect_base }
+          e = assert_raises Stripe::OAuth::InvalidGrantError do
+            client.execute_request(:post, "/oauth/token", opts)
+          end
+
+          assert_equal(400, e.http_status)
+          assert_equal("invalid_grant", e.code)
+          assert_equal("This authorization code has already been used. All tokens issued with this code have been revoked.", e.message)
+        end
+
+        should "raise OAuth::InvalidClientError when error is a string with value 'invalid_client'" do
+          stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize")
+            .to_return(body: JSON.generate(error: "invalid_client",
+                                           error_description: "This application is not connected to stripe account acct_19tLK7DSlTMT26Mk, or that account does not exist."), status: 401)
+
+          client = StripeClient.new
+          opts = { api_base: Stripe.connect_base }
+          e = assert_raises Stripe::OAuth::InvalidClientError do
+            client.execute_request(:post, "/oauth/deauthorize", opts)
+          end
+
+          assert_equal(401, e.http_status)
+          assert_equal("invalid_client", e.code)
+          assert_equal("This application is not connected to stripe account acct_19tLK7DSlTMT26Mk, or that account does not exist.", e.message)
+        end
+
+        should "raise Stripe::OAuthError on indeterminate OAuth error" do
+          stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize")
+            .to_return(body: JSON.generate(error: "new_code_not_recognized",
+                                           error_description: "Something."), status: 401)
+
+          client = StripeClient.new
+          opts = { api_base: Stripe.connect_base }
+          e = assert_raises Stripe::OAuth::OAuthError do
+            client.execute_request(:post, "/oauth/deauthorize", opts)
+          end
+
+          assert_equal(401, e.http_status)
+          assert_equal("new_code_not_recognized", e.code)
+          assert_equal("Something.", e.message)
+        end
+      end
+
+      context "idempotency keys" do
+        setup do
+          Stripe.stubs(:max_network_retries).returns(2)
+        end
+
+        should "not add an idempotency key to GET requests" do
+          SecureRandom.expects(:uuid).times(0)
+          stub_request(:get, "#{Stripe.api_base}/v1/charges/ch_123")
+            .with do |req|
+              req.headers["Idempotency-Key"].nil?
+            end.to_return(body: JSON.generate(object: "charge"))
+          client = StripeClient.new
+          client.execute_request(:get, "/v1/charges/ch_123")
+        end
+
+        should "ensure there is always an idempotency_key on POST requests" do
+          SecureRandom.expects(:uuid).at_least_once.returns("random_key")
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .with(headers: { "Idempotency-Key" => "random_key" })
+            .to_return(body: JSON.generate(object: "charge"))
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/charges")
+        end
+
+        should "ensure there is always an idempotency_key on DELETE requests" do
+          SecureRandom.expects(:uuid).at_least_once.returns("random_key")
+          stub_request(:delete, "#{Stripe.api_base}/v1/charges/ch_123")
+            .with(headers: { "Idempotency-Key" => "random_key" })
+            .to_return(body: JSON.generate(object: "charge"))
+          client = StripeClient.new
+          client.execute_request(:delete, "/v1/charges/ch_123")
+        end
+
+        should "not override a provided idempotency_key" do
+          # Note that this expectation looks like `:idempotency_key` instead of
+          # the header `Idempotency-Key` because it's user provided as seen
+          # below. The ones injected by the library itself look like headers
+          # (`Idempotency-Key`), but rest-client does allow this symbol
+          # formatting and will properly override the system generated one as
+          # expected.
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .with(headers: { "Idempotency-Key" => "provided_key" })
+            .to_return(body: JSON.generate(object: "charge"))
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/charges",
+                                 headers: { idempotency_key: "provided_key" })
+        end
+      end
+
+      context "retry logic" do
+        setup do
+          Stripe.stubs(:max_network_retries).returns(2)
+        end
+
+        should "retry failed requests and raise if error persists" do
+          StripeClient.expects(:sleep_time).at_least_once.returns(0)
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_raise(Errno::ECONNREFUSED.new)
+
+          client = StripeClient.new
+          err = assert_raises Stripe::APIConnectionError do
+            client.execute_request(:post, "/v1/charges")
+          end
+          assert_match(/Request was retried 2 times/, err.message)
+        end
+
+        should "retry failed requests and return successful response" do
+          StripeClient.expects(:sleep_time).at_least_once.returns(0)
+
+          i = 0
+          stub_request(:post, "#{Stripe.api_base}/v1/charges")
+            .to_return do |_|
+              if i < 2
+                i += 1
+                raise Errno::ECONNREFUSED
+              else
+                { body: JSON.generate("id" => "myid") }
+              end
+            end
+
+          client = StripeClient.new
+          client.execute_request(:post, "/v1/charges")
+        end
+      end
+
+      context "params serialization" do
+        should "allows empty strings in params" do
+          client = StripeClient.new
+          client.execute_request(:get, "/v1/invoices/upcoming", params: {
+            customer: "cus_123",
+            coupon: "",
+          })
+          assert_requested(
+            :get,
+            "#{Stripe.api_base}/v1/invoices/upcoming?",
+            query: {
+              customer: "cus_123",
+              coupon: "",
+            }
+          )
+        end
+
+        should "filter nils in params" do
+          client = StripeClient.new
+          client.execute_request(:get, "/v1/invoices/upcoming", params: {
+            customer: "cus_123",
+            coupon: nil,
+          })
+          assert_requested(
+            :get,
+            "#{Stripe.api_base}/v1/invoices/upcoming?",
+            query: {
+              customer: "cus_123",
+            }
+          )
+        end
+
+        should "merge query parameters in URL and params" do
+          client = StripeClient.new
+          client.execute_request(:get, "/v1/invoices/upcoming?coupon=25OFF", params: {
+            customer: "cus_123",
+          })
+          assert_requested(
+            :get,
+            "#{Stripe.api_base}/v1/invoices/upcoming?",
+            query: {
+              coupon: "25OFF",
+              customer: "cus_123",
+            }
+          )
+        end
+
+        should "prefer query parameters in params when specified in URL as well" do
+          client = StripeClient.new
+          client.execute_request(:get, "/v1/invoices/upcoming?customer=cus_query", params: {
+            customer: "cus_param",
+          })
+          assert_requested(
+            :get,
+            "#{Stripe.api_base}/v1/invoices/upcoming?",
+            query: {
+              customer: "cus_param",
+            }
+          )
+        end
+      end
+    end
+
+    context "#request" do
+      should "return a result and response object" do
+        stub_request(:post, "#{Stripe.api_base}/v1/charges")
+          .to_return(body: JSON.generate(object: "charge"))
+
+        client = StripeClient.new
+        charge, resp = client.request { Charge.create }
+
+        assert charge.is_a?(Charge)
+        assert resp.is_a?(StripeResponse)
+        assert_equal 200, resp.http_status
+      end
+
+      should "return the value of given block" do
+        client = StripeClient.new
+        ret, = client.request { 7 }
+        assert_equal 7, ret
+      end
+
+      should "reset local thread state after a call" do
+        begin
+          Thread.current[:stripe_client] = :stripe_client
+
+          client = StripeClient.new
+          client.request {}
+
+          assert_equal :stripe_client, Thread.current[:stripe_client]
+        ensure
+          Thread.current[:stripe_client] = nil
+        end
+      end
+    end
+
+    context "#proxy" do
+      should "run the request through the proxy" do
+        begin
+          Thread.current[:stripe_client_default_conn] = nil
+
+          Stripe.proxy = "http://localhost:8080"
+
+          client = StripeClient.new
+          client.request {}
+
+          assert_equal "http://localhost:8080", Stripe::StripeClient.default_conn.proxy.uri.to_s
+        ensure
+          Stripe.proxy = nil
+
+          Thread.current[:stripe_client_default_conn] = nil
+        end
+      end
+    end
+
+    context "#telemetry" do
+      teardown do
+        # make sure to always set telemetry back to false
+        # to not mutate global state
+        Stripe.enable_telemetry = false
+      end
+
+      should "not send metrics if enable trace flag is not set" do
+        Stripe.enable_telemetry = false
+
+        trace_metrics_header = nil
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with do |req|
+          trace_metrics_header = req.headers["X-Stripe-Client-Telemetry"]
+          false
+        end.to_return(body: JSON.generate(object: "charge"))
+
+        Stripe::Charge.list
+        assert(trace_metrics_header.nil?)
+
+        Stripe::Charge.list
+        assert(trace_metrics_header.nil?)
+      end
+
+      should "send metrics if enabled telemetry is true" do
+        Stripe.enable_telemetry = true
+
+        trace_metrics_header = nil
+        stub_request(:get, "#{Stripe.api_base}/v1/charges")
+          .with do |req|
+          trace_metrics_header = req.headers["X-Stripe-Client-Telemetry"]
+          false
+        end.to_return(body: JSON.generate(object: "charge"))
+
+        Stripe::Charge.list
+        Stripe::Charge.list
+
+        assert(!trace_metrics_header.nil?)
+
+        trace_payload = JSON.parse(trace_metrics_header)
+        assert(trace_payload["last_request_metrics"]["request_id"] == "req_123")
+        assert(!trace_payload["last_request_metrics"]["request_duration_ms"].nil?)
+      end
+    end
+  end
+
+  class SystemProfilerTest < Test::Unit::TestCase
+    context "#uname" do
+      should "run without failure" do
+        # Don't actually check the result because we try a variety of different
+        # strategies that will have different results depending on where this
+        # test and running. We're mostly making sure that no exception is thrown.
+        _ = StripeClient::SystemProfiler.uname
+      end
+    end
+
+    context "#uname_from_system" do
+      should "run without failure" do
+        # as above, just verify that an exception is not thrown
+        _ = StripeClient::SystemProfiler.uname_from_system
+      end
+    end
+
+    context "#uname_from_system_ver" do
+      should "run without failure" do
+        # as above, just verify that an exception is not thrown
+        _ = StripeClient::SystemProfiler.uname_from_system_ver
+      end
+    end
+  end
+end