stripe 3.2.0 → 5.16.0

data/test/stripe/apple_pay_domain_test.rb

@@ -1,31 +1,46 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class ApplePayDomainTest < Test::Unit::TestCase
     should "be listable" do
       domains = Stripe::ApplePayDomain.list
       assert_requested :get, "#{Stripe.api_base}/v1/apple_pay/domains"
-      assert domains.data.kind_of?(Array)
-      assert domains.data[0].kind_of?(Stripe::ApplePayDomain)
+      assert domains.data.is_a?(Array)
+      assert domains.data[0].is_a?(Stripe::ApplePayDomain)
     end
 
     should "be retrievable" do
       domain = Stripe::ApplePayDomain.retrieve("apwc_123")
-    assert_requested :get, "#{Stripe.api_base}/v1/apple_pay/domains/apwc_123"
-      assert domain.kind_of?(Stripe::ApplePayDomain)
+      assert_requested :get, "#{Stripe.api_base}/v1/apple_pay/domains/apwc_123"
+      assert domain.is_a?(Stripe::ApplePayDomain)
     end
 
     should "be creatable" do
-      domain = Stripe::ApplePayDomain.create(:domain_name => "example.com")
+      domain = Stripe::ApplePayDomain.create(domain_name: "example.com")
       assert_requested :post, "#{Stripe.api_base}/v1/apple_pay/domains"
-      assert domain.kind_of?(Stripe::ApplePayDomain)
+      assert domain.is_a?(Stripe::ApplePayDomain)
     end
 
     should "be deletable" do
-      domain = Stripe::ApplePayDomain.retrieve("apwc_123")
-      domain = domain.delete
-      assert_requested :delete, "#{Stripe.api_base}/v1/apple_pay/domains/#{domain.id}"
-      assert domain.kind_of?(Stripe::ApplePayDomain)
+    end
+
+    context "#delete" do
+      should "be deletable" do
+        domain = Stripe::ApplePayDomain.retrieve("apwc_123")
+        domain = domain.delete
+        assert_requested :delete, "#{Stripe.api_base}/v1/apple_pay/domains/#{domain.id}"
+        assert domain.is_a?(Stripe::ApplePayDomain)
+      end
+    end
+
+    context ".delete" do
+      should "be deletable" do
+        domain = Stripe::ApplePayDomain.delete("apwc_123")
+        assert_requested :delete, "#{Stripe.api_base}/v1/apple_pay/domains/apwc_123"
+        assert domain.is_a?(Stripe::ApplePayDomain)
+      end
     end
   end
 end

data/test/stripe/application_fee_refund_test.rb

@@ -1,4 +1,6 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class ApplicationFeeRefundTest < Test::Unit::TestCase
@@ -11,25 +13,25 @@ module Stripe
 
       # notably this *doesn't* make an API call
       assert_not_requested :get,
-        "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds"
+                           "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds"
 
-      assert refunds.data.kind_of?(Array)
-      assert refunds.first.kind_of?(Stripe::ApplicationFeeRefund)
+      assert refunds.data.is_a?(Array)
+      assert refunds.first.is_a?(Stripe::ApplicationFeeRefund)
     end
 
     should "be creatable" do
       refund = @fee.refunds.create
       assert_requested :post,
-        "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds"
-      assert refund.kind_of?(Stripe::ApplicationFeeRefund)
+                       "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds"
+      assert refund.is_a?(Stripe::ApplicationFeeRefund)
     end
 
     should "be saveable" do
       refund = @fee.refunds.first
-      refund.metadata['key'] = 'value'
+      refund.metadata["key"] = "value"
       refund.save
       assert_requested :post,
-        "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds/#{refund.id}"
+                       "#{Stripe.api_base}/v1/application_fees/#{@fee.id}/refunds/#{refund.id}"
     end
   end
 end

data/test/stripe/application_fee_test.rb

@@ -1,12 +1,58 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class ApplicationFeeTest < Test::Unit::TestCase
     should "be listable" do
       fees = Stripe::ApplicationFee.list
       assert_requested :get, "#{Stripe.api_base}/v1/application_fees"
-      assert fees.data.kind_of?(Array)
-      assert fees.data[0].kind_of?(Stripe::ApplicationFee)
+      assert fees.data.is_a?(Array)
+      assert fees.data[0].is_a?(Stripe::ApplicationFee)
+    end
+
+    context "#create_refund" do
+      should "create a refund" do
+        refund = Stripe::ApplicationFee.create_refund(
+          "fee_123"
+        )
+        assert_requested :post, "#{Stripe.api_base}/v1/application_fees/fee_123/refunds"
+        assert refund.is_a?(Stripe::ApplicationFeeRefund)
+      end
+    end
+
+    context "#retrieve_refund" do
+      should "retrieve a refund" do
+        refund = Stripe::ApplicationFee.retrieve_refund(
+          "fee_123",
+          "fr_123"
+        )
+        assert_requested :get, "#{Stripe.api_base}/v1/application_fees/fee_123/refunds/fr_123"
+        assert refund.is_a?(Stripe::ApplicationFeeRefund)
+      end
+    end
+
+    context "#update_refund" do
+      should "update a refund" do
+        refund = Stripe::ApplicationFee.update_refund(
+          "fee_123",
+          "fr_123",
+          metadata: { foo: "bar" }
+        )
+        assert_requested :post, "#{Stripe.api_base}/v1/application_fees/fee_123/refunds/fr_123"
+        assert refund.is_a?(Stripe::ApplicationFeeRefund)
+      end
+    end
+
+    context "#list_refunds" do
+      should "list the application fee's refuns" do
+        refunds = Stripe::ApplicationFee.list_refunds(
+          "fee_123"
+        )
+        assert_requested :get, "#{Stripe.api_base}/v1/application_fees/fee_123/refunds"
+        assert refunds.is_a?(Stripe::ListObject)
+        assert refunds.data.is_a?(Array)
+      end
     end
   end
 end

data/test/stripe/balance_test.rb

@@ -1,11 +1,13 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class BalanceTest < Test::Unit::TestCase
     should "be retrievable" do
       balance = Stripe::Balance.retrieve
       assert_requested :get, "#{Stripe.api_base}/v1/balance"
-      assert balance.kind_of?(Stripe::Balance)
+      assert balance.is_a?(Stripe::Balance)
     end
   end
 end

data/test/stripe/balance_transaction_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class BalanceTransactionTest < Test::Unit::TestCase
+    should "be listable" do
+      balance_transactions = Stripe::BalanceTransaction.list
+      assert_requested :get, "#{Stripe.api_base}/v1/balance_transactions"
+      assert balance_transactions.data.is_a?(Array)
+      assert balance_transactions.first.is_a?(Stripe::BalanceTransaction)
+    end
+
+    should "be retrievable" do
+      balance_transaction = Stripe::BalanceTransaction.retrieve("txn_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/balance_transactions/txn_123"
+      assert balance_transaction.is_a?(Stripe::BalanceTransaction)
+    end
+  end
+end

data/test/stripe/bank_account_test.rb

@@ -1,4 +1,6 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class BankAccountTest < Test::Unit::TestCase
@@ -9,27 +11,25 @@ module Stripe
           id: "ba_123"
         )
         assert_equal "/v1/accounts/acct_123/external_accounts/ba_123",
-          bank_account.resource_url
+                     bank_account.resource_url
       end
 
       should "return a customer URL" do
         bank_account = Stripe::BankAccount.construct_from(
           customer: "cus_123",
-          id: "ba_123",
+          id: "ba_123"
         )
         assert_equal "/v1/customers/cus_123/sources/ba_123",
-          bank_account.resource_url
+                     bank_account.resource_url
       end
     end
 
     context "#verify" do
-      should 'verify the account' do
-        bank_account = Stripe::BankAccount.construct_from({
-          customer: "cus_123",
-          id: "ba_123",
-        })
-        bank_account = bank_account.verify(amounts: [1,2])
-        assert bank_account.kind_of?(Stripe::BankAccount)
+      should "verify the account" do
+        bank_account = Stripe::BankAccount.construct_from(customer: "cus_123",
+                                                          id: "ba_123")
+        bank_account = bank_account.verify(amounts: [1, 2])
+        assert bank_account.is_a?(Stripe::BankAccount)
       end
     end
   end

data/test/stripe/capability_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class CapabilityTest < Test::Unit::TestCase
+    context "#resource_url" do
+      should "return a resource URL" do
+        capability = Stripe::Capability.construct_from(
+          id: "acap_123",
+          account: "acct_123"
+        )
+        assert_equal "/v1/accounts/acct_123/capabilities/acap_123",
+                     capability.resource_url
+      end
+
+      should "raise without an account" do
+        capability = Stripe::Capability.construct_from(id: "acap_123")
+        assert_raises NotImplementedError do
+          capability.resource_url
+        end
+      end
+    end
+
+    should "raise on #retrieve" do
+      assert_raises NotImplementedError do
+        Stripe::Capability.retrieve("acap_123")
+      end
+    end
+
+    should "raise on #update" do
+      assert_raises NotImplementedError do
+        Stripe::Capability.update("acap_123", {})
+      end
+    end
+
+    should "be saveable" do
+      capability = Stripe::Account.retrieve_capability("acct_123", "acap_123")
+      capability.requested = true
+      capability.save
+      assert_requested :post,
+                       "#{Stripe.api_base}/v1/accounts/#{capability.account}/capabilities/#{capability.id}"
+    end
+  end
+end

data/test/stripe/charge_test.rb

@@ -1,56 +1,63 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class ChargeTest < Test::Unit::TestCase
     should "be listable" do
       charges = Stripe::Charge.list
       assert_requested :get, "#{Stripe.api_base}/v1/charges"
-      assert charges.data.kind_of?(Array)
-      assert charges.data[0].kind_of?(Stripe::Charge)
+      assert charges.data.is_a?(Array)
+      assert charges.data[0].is_a?(Stripe::Charge)
     end
 
     should "be retrievable" do
       charge = Stripe::Charge.retrieve("ch_123")
       assert_requested :get, "#{Stripe.api_base}/v1/charges/ch_123"
-      assert charge.kind_of?(Stripe::Charge)
+      assert charge.is_a?(Stripe::Charge)
     end
 
     should "be creatable" do
       charge = Stripe::Charge.create(
         amount: 100,
         currency: "USD",
-        source: "src_123",
+        source: "src_123"
       )
       assert_requested :post, "#{Stripe.api_base}/v1/charges"
-      assert charge.kind_of?(Stripe::Charge)
+      assert charge.is_a?(Stripe::Charge)
     end
 
     should "be saveable" do
       charge = Stripe::Charge.retrieve("ch_123")
-      charge.metadata['key'] = 'value'
+      charge.metadata["key"] = "value"
       charge.save
       assert_requested :post, "#{Stripe.api_base}/v1/charges/#{charge.id}"
     end
 
     should "be updateable" do
-      charge = Stripe::Charge.update("ch_123", metadata: {foo: 'bar'})
+      charge = Stripe::Charge.update("ch_123", metadata: { foo: "bar" })
       assert_requested :post, "#{Stripe.api_base}/v1/charges/ch_123"
-      assert charge.kind_of?(Stripe::Charge)
+      assert charge.is_a?(Stripe::Charge)
     end
 
-    context "#mark_as_fraudulent" do
-      should "charges should be able to be marked as fraudulent" do
+    context "#capture" do
+      should "capture the charge" do
         charge = Stripe::Charge.retrieve("ch_123")
-        charge = charge.mark_as_fraudulent
-        assert charge.kind_of?(Stripe::Charge)
+        charge = charge.capture(amount: 100)
+        assert_requested :post,
+                         "#{Stripe.api_base}/v1/charges/ch_123/capture",
+                         body: { amount: 100 }
+        assert charge.is_a?(Stripe::Charge)
       end
     end
 
-    context "#mark_as_safe" do
-      should "charges should be able to be marked as safe" do
-        charge = Stripe::Charge.retrieve("ch_123")
-        charge = charge.mark_as_safe
-        assert charge.kind_of?(Stripe::Charge)
+    context ".capture" do
+      should "capture the charge" do
+        charge = Stripe::Charge.capture("ch_123", amount: 100)
+        assert_requested :post,
+                         "#{Stripe.api_base}/v1/charges/ch_123/capture",
+                         body: { amount: 100 }
+        assert charge.is_a?(Stripe::Charge)
       end
     end
   end

data/test/stripe/checkout/session_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../../test_helper", __dir__)
+
+module Stripe
+  module Checkout
+    class SessionTest < Test::Unit::TestCase
+      should "be creatable" do
+        session = Stripe::Checkout::Session.create(
+          cancel_url: "https://stripe.com/cancel",
+          client_reference_id: "1234",
+          line_items: [
+            {
+              amount: 123,
+              currency: "usd",
+              description: "item 1",
+              images: [
+                "https://stripe.com/img1",
+              ],
+              name: "name",
+              quantity: 2,
+            },
+          ],
+          payment_intent_data: [
+            receipt_email: "test@stripe.com",
+          ],
+          payment_method_types: ["card"],
+          success_url: "https://stripe.com/success"
+        )
+        assert_requested :post, "#{Stripe.api_base}/v1/checkout/sessions"
+        assert session.is_a?(Stripe::Checkout::Session)
+      end
+
+      should "be retrievable" do
+        charge = Stripe::Checkout::Session.retrieve("cs_123")
+        assert_requested :get, "#{Stripe.api_base}/v1/checkout/sessions/cs_123"
+        assert charge.is_a?(Stripe::Checkout::Session)
+      end
+    end
+  end
+end

data/test/stripe/connection_manager_test.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class ConnectionManagerTest < Test::Unit::TestCase
+    setup do
+      @manager = Stripe::ConnectionManager.new
+    end
+
+    context "#initialize" do
+      should "set #last_used to current time" do
+        t = 123.0
+        Util.stubs(:monotonic_time).returns(t)
+        assert_equal t, Stripe::ConnectionManager.new.last_used
+      end
+    end
+
+    context "#clear" do
+      should "clear any active connections" do
+        stub_request(:post, "#{Stripe.api_base}/path")
+          .to_return(body: JSON.generate(object: "account"))
+
+        # Making a request lets us know that at least one connection is open.
+        @manager.execute_request(:post, "#{Stripe.api_base}/path")
+
+        # Now clear the manager.
+        @manager.clear
+
+        # 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
+
+    context "#connection_for" do
+      should "correctly initialize a connection" do
+        old_proxy = Stripe.proxy
+
+        old_open_timeout = Stripe.open_timeout
+        old_read_timeout = Stripe.read_timeout
+
+        begin
+          # Make sure any global initialization here is undone in the `ensure`
+          # block below.
+          Stripe.proxy = "http://user:pass@localhost:8080"
+
+          Stripe.open_timeout = 123
+          Stripe.read_timeout = 456
+
+          conn = @manager.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 "user", conn.proxy_user
+          assert_equal "pass", conn.proxy_pass
+
+          # Timeouts
+          assert_equal 123, conn.open_timeout
+          assert_equal 456, 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
+
+      should "produce the same connection multiple times" do
+        conn1 = @manager.connection_for("https://stripe.com")
+        conn2 = @manager.connection_for("https://stripe.com")
+
+        assert_equal conn1, conn2
+      end
+
+      should "produce different connections for different hosts" do
+        conn1 = @manager.connection_for("https://example.com")
+        conn2 = @manager.connection_for("https://stripe.com")
+
+        refute_equal conn1, conn2
+      end
+
+      should "produce different connections for different ports" do
+        conn1 = @manager.connection_for("https://stripe.com:80")
+        conn2 = @manager.connection_for("https://stripe.com:443")
+
+        refute_equal conn1, conn2
+      end
+    end
+
+    context "#execute_request" do
+      should "make a request" do
+        stub_request(:post, "#{Stripe.api_base}/path?query=bar")
+          .with(
+            body: "body=foo",
+            headers: { "Stripe-Account" => "bar" }
+          )
+          .to_return(body: JSON.generate(object: "account"))
+
+        @manager.execute_request(:post, "#{Stripe.api_base}/path",
+                                 body: "body=foo",
+                                 headers: { "Stripe-Account" => "bar" },
+                                 query: "query=bar")
+      end
+
+      should "perform basic argument validation" do
+        e = assert_raises ArgumentError do
+          @manager.execute_request("POST", "#{Stripe.api_base}/path")
+        end
+        assert_equal e.message, "method should be a symbol"
+
+        e = assert_raises ArgumentError do
+          @manager.execute_request(:post, :uri)
+        end
+        assert_equal e.message, "uri should be a string"
+
+        e = assert_raises ArgumentError do
+          @manager.execute_request(:post, "#{Stripe.api_base}/path",
+                                   body: {})
+        end
+        assert_equal e.message, "body should be a string"
+
+        e = assert_raises ArgumentError do
+          @manager.execute_request(:post, "#{Stripe.api_base}/path",
+                                   headers: "foo")
+        end
+        assert_equal e.message, "headers should be a hash"
+
+        e = assert_raises ArgumentError do
+          @manager.execute_request(:post, "#{Stripe.api_base}/path",
+                                   query: {})
+        end
+        assert_equal e.message, "query should be a string"
+      end
+
+      should "set #last_used to current time" do
+        stub_request(:post, "#{Stripe.api_base}/path")
+          .to_return(body: JSON.generate(object: "account"))
+
+        t = 123.0
+        Util.stubs(:monotonic_time).returns(t)
+
+        manager = Stripe::ConnectionManager.new
+
+        # `#last_used` is also set by the constructor, so make sure we get a
+        # new value for it.
+        Util.stubs(:monotonic_time).returns(t + 1.0)
+
+        manager.execute_request(:post, "#{Stripe.api_base}/path")
+        assert_equal t + 1.0, manager.last_used
+      end
+    end
+  end
+end

data/test/stripe/country_spec_test.rb

@@ -1,18 +1,20 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class CountrySpecTest < Test::Unit::TestCase
     should "be listable" do
       c = Stripe::CountrySpec.list
       assert_requested :get, "#{Stripe.api_base}/v1/country_specs"
-      assert c.data.kind_of?(Array)
-      assert c.data[0].kind_of?(Stripe::CountrySpec)
+      assert c.data.is_a?(Array)
+      assert c.data[0].is_a?(Stripe::CountrySpec)
     end
 
     should "be retrievable" do
       s = Stripe::CountrySpec.retrieve("US")
       assert_requested :get, "#{Stripe.api_base}/v1/country_specs/US"
-      assert(s.kind_of?(Stripe::CountrySpec))
+      assert(s.is_a?(Stripe::CountrySpec))
     end
   end
 end

data/test/stripe/coupon_test.rb

@@ -1,42 +1,61 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class CouponTest < Test::Unit::TestCase
     should "be listable" do
       coupons = Stripe::Coupon.list
       assert_requested :get, "#{Stripe.api_base}/v1/coupons"
-      assert coupons.data.kind_of?(Array)
-      assert coupons.first.kind_of?(Stripe::Coupon)
+      assert coupons.data.is_a?(Array)
+      assert coupons.first.is_a?(Stripe::Coupon)
     end
 
     should "be retrievable" do
       coupon = Stripe::Coupon.retrieve("25OFF")
       assert_requested :get, "#{Stripe.api_base}/v1/coupons/25OFF"
-      assert coupon.kind_of?(Stripe::Coupon)
+      assert coupon.is_a?(Stripe::Coupon)
     end
 
     should "be creatable" do
       coupon = Stripe::Coupon.create(
         percent_off: 25,
-        duration: 'repeating',
+        duration: "repeating",
         duration_in_months: 3,
-        id: '25OFF'
+        id: "25OFF"
       )
       assert_requested :post, "#{Stripe.api_base}/v1/coupons"
-      assert coupon.kind_of?(Stripe::Coupon)
+      assert coupon.is_a?(Stripe::Coupon)
     end
 
     should "be saveable" do
       coupon = Stripe::Coupon.retrieve("25OFF")
-      coupon.metadata['key'] = 'value'
+      coupon.metadata["key"] = "value"
       coupon.save
       assert_requested :post, "#{Stripe.api_base}/v1/coupons/#{coupon.id}"
     end
 
     should "be updateable" do
-      coupon = Stripe::Coupon.update("25OFF", metadata: { key: 'value' })
+      coupon = Stripe::Coupon.update("25OFF", metadata: { key: "value" })
       assert_requested :post, "#{Stripe.api_base}/v1/coupons/25OFF"
-      assert coupon.kind_of?(Stripe::Coupon)
+      assert coupon.is_a?(Stripe::Coupon)
+    end
+
+    context "#delete" do
+      should "be deletable" do
+        coupon = Stripe::Coupon.delete("25OFF")
+        assert_requested :delete, "#{Stripe.api_base}/v1/coupons/#{coupon.id}"
+        assert coupon.is_a?(Stripe::Coupon)
+      end
+    end
+
+    context ".delete" do
+      should "be deletable" do
+        coupon = Stripe::Coupon.retrieve("25OFF")
+        coupon = coupon.delete
+        assert_requested :delete, "#{Stripe.api_base}/v1/coupons/25OFF"
+        assert coupon.is_a?(Stripe::Coupon)
+      end
     end
   end
 end