stripe 3.2.0 → 5.16.0

data/test/stripe/multipart_encoder_test.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class MultipartEncoderTest < Test::Unit::TestCase
+    should "multipart encode parameters" do
+      Tempfile.create("image.jpg") do |f|
+        f.write "file-content"
+        f.flush
+        f.rewind
+
+        encoder = MultipartEncoder.new
+        encoder.encode(
+          file: f,
+          other_param: "other-param-content"
+        )
+        encoder.close
+        body = encoder.body
+
+        assert_equal <<~BODY.rstrip, body
+          --#{encoder.boundary}\r
+          Content-Disposition: form-data; name="file"; filename="#{::File.basename(f.path)}"\r
+          Content-Type: application/octet-stream\r
+          \r
+          file-content\r
+          --#{encoder.boundary}\r
+          Content-Disposition: form-data; name="other_param"\r
+          \r
+          other-param-content\r
+          --#{encoder.boundary}--
+        BODY
+      end
+    end
+
+    should "encode file-like objects" do
+      klass = Class.new do
+        def read
+          "klass-read-content"
+        end
+      end
+
+      encoder = MultipartEncoder.new
+      encoder.encode(
+        file_like: klass.new
+      )
+      encoder.close
+      body = encoder.body
+
+      assert_equal <<~BODY.rstrip, body
+        --#{encoder.boundary}\r
+        Content-Disposition: form-data; name="file_like"; filename="blob"\r
+        Content-Type: application/octet-stream\r
+        \r
+        klass-read-content\r
+        --#{encoder.boundary}--
+      BODY
+    end
+
+    should "escape quotes and line break characters in parameter names" do
+      encoder = MultipartEncoder.new
+      encoder.encode(
+        %("quoted\n\r") => "content"
+      )
+      encoder.close
+      body = encoder.body
+
+      assert_equal <<~BODY.rstrip, body
+        --#{encoder.boundary}\r
+        Content-Disposition: form-data; name="%22quoted  %22"\r
+        \r
+        content\r
+        --#{encoder.boundary}--
+      BODY
+    end
+
+    context ".encode" do
+      should "provide an easy encoding shortcut" do
+        body, content_type = MultipartEncoder.encode(
+          param: "content"
+        )
+        assert_include body, %(Content-Disposition: form-data; name="param")
+        assert_include content_type, "#{MultipartEncoder::MULTIPART_FORM_DATA}; boundary="
+      end
+    end
+
+    context "#body" do
+      should "error if not yet closed" do
+        encoder = MultipartEncoder.new
+
+        e = assert_raises RuntimeError do
+          encoder.body
+        end
+        assert_equal "object must be closed before getting body", e.message
+      end
+    end
+
+    context "#close" do
+      should "error if closed twice" do
+        encoder = MultipartEncoder.new
+        encoder.close
+
+        e = assert_raises RuntimeError do
+          encoder.close
+        end
+        assert_equal "object already closed", e.message
+      end
+    end
+
+    context "#content_type" do
+      should "produce a content type containing boundary" do
+        encoder = MultipartEncoder.new
+        assert_equal "#{MultipartEncoder::MULTIPART_FORM_DATA}; boundary=#{encoder.boundary}",
+                     encoder.content_type
+      end
+    end
+
+    context "#encode" do
+      should "error if already closed" do
+        encoder = MultipartEncoder.new
+        encoder.close
+
+        e = assert_raises RuntimeError do
+          encoder.encode(param: "content")
+        end
+        assert_equal "no more parameters can be written to closed object", e.message
+      end
+    end
+  end
+end

data/test/stripe/oauth_test.rb

@@ -1,9 +1,11 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class OAuthTest < Test::Unit::TestCase
     setup do
-      Stripe.client_id = 'ca_test'
+      Stripe.client_id = "ca_test"
     end
 
     teardown do
@@ -12,28 +14,35 @@ module Stripe
 
     context ".authorize_url" do
       should "return the authorize URL" do
-        uri_str = OAuth.authorize_url({
-          scope: 'read_write',
-          state: 'csrf_token',
-          stripe_user: {
-            email: 'test@example.com',
-            url: 'https://example.com/profile/test',
-            country: 'US',
-          },
-        })
+        uri_str = OAuth.authorize_url(scope: "read_write",
+                                      state: "csrf_token",
+                                      stripe_user: {
+                                        email: "test@example.com",
+                                        url: "https://example.com/profile/test",
+                                        country: "US",
+                                      })
+
+        uri = URI.parse(uri_str)
+        params = CGI.parse(uri.query)
 
-        uri = URI::parse(uri_str)
-        params = CGI::parse(uri.query)
+        assert_equal("https", uri.scheme)
+        assert_equal("connect.stripe.com", uri.host)
+        assert_equal("/oauth/authorize", uri.path)
+
+        assert_equal(["ca_test"], params["client_id"])
+        assert_equal(["read_write"], params["scope"])
+        assert_equal(["test@example.com"], params["stripe_user[email]"])
+        assert_equal(["https://example.com/profile/test"], params["stripe_user[url]"])
+        assert_equal(["US"], params["stripe_user[country]"])
+      end
 
-        assert_equal('https', uri.scheme)
-        assert_equal('connect.stripe.com', uri.host)
-        assert_equal('/oauth/authorize', uri.path)
+      should "optionally return an express path" do
+        uri_str = OAuth.authorize_url({}, express: true)
 
-        assert_equal(['ca_test'], params['client_id'])
-        assert_equal(['read_write'], params['scope'])
-        assert_equal(['test@example.com'], params['stripe_user[email]'])
-        assert_equal(['https://example.com/profile/test'], params['stripe_user[url]'])
-        assert_equal(['US'], params['stripe_user[country]'])
+        uri = URI.parse(uri_str)
+        assert_equal("https", uri.scheme)
+        assert_equal("connect.stripe.com", uri.host)
+        assert_equal("/express/oauth/authorize", uri.path)
       end
     end
 
@@ -41,26 +50,38 @@ module Stripe
       should "exchange a code for an access token" do
         # The OpenAPI fixtures don't cover the OAuth endpoints, so we just
         # stub the request manually.
-        stub_request(:post, "#{Stripe.connect_base}/oauth/token").
-          with(body: {
-            'grant_type' => 'authorization_code',
-            'code' => 'this_is_an_authorization_code',
-          }).
-          to_return(body: JSON.generate({
-            access_token: 'sk_access_token',
-            scope: 'read_only',
-            livemode: false,
-            token_type: 'bearer',
-            refresh_token: 'sk_refresh_token',
-            stripe_user_id: 'acct_test',
-            stripe_publishable_key: 'pk_test',
-          }))
+        stub_request(:post, "#{Stripe.connect_base}/oauth/token")
+          .with(body: {
+            "grant_type" => "authorization_code",
+            "code" => "this_is_an_authorization_code",
+          })
+          .to_return(body: JSON.generate(access_token: "sk_access_token",
+                                         scope: "read_only",
+                                         livemode: false,
+                                         token_type: "bearer",
+                                         refresh_token: "sk_refresh_token",
+                                         stripe_user_id: "acct_test",
+                                         stripe_publishable_key: "pk_test"))
+
+        resp = OAuth.token(grant_type: "authorization_code",
+                           code: "this_is_an_authorization_code")
+        assert_equal("sk_access_token", resp.access_token)
+      end
+
+      should "override the API key when client_secret is passed" do
+        stub_request(:post, "#{Stripe.connect_base}/oauth/token")
+          .with(body: {
+            "client_secret" => "client_secret_override",
+            "grant_type" => "authorization_code",
+            "code" => "this_is_an_authorization_code",
+          })
+          .with(headers: { "Authorization": "Bearer client_secret_override" })
+          .to_return(body: JSON.generate(access_token: "another_access_token"))
 
-        resp = OAuth.token({
-          grant_type: 'authorization_code',
-          code: 'this_is_an_authorization_code',
-        })
-        assert_equal('sk_access_token', resp.access_token)
+        resp = OAuth.token(client_secret: "client_secret_override",
+                           grant_type: "authorization_code",
+                           code: "this_is_an_authorization_code")
+        assert_equal("another_access_token", resp.access_token)
       end
     end
 
@@ -68,17 +89,15 @@ module Stripe
       should "deauthorize an account" do
         # The OpenAPI fixtures don't cover the OAuth endpoints, so we just
         # stub the request manually.
-        stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize").
-          with(body: {
-            'client_id' => 'ca_test',
-            'stripe_user_id' => 'acct_test_deauth',
-          }).
-          to_return(body: JSON.generate({
-            stripe_user_id: 'acct_test_deauth',
-          }))
+        stub_request(:post, "#{Stripe.connect_base}/oauth/deauthorize")
+          .with(body: {
+            "client_id" => "ca_test",
+            "stripe_user_id" => "acct_test_deauth",
+          })
+          .to_return(body: JSON.generate(stripe_user_id: "acct_test_deauth"))
 
-        resp = OAuth.deauthorize({stripe_user_id: 'acct_test_deauth'})
-        assert_equal('acct_test_deauth', resp.stripe_user_id)
+        resp = OAuth.deauthorize(stripe_user_id: "acct_test_deauth")
+        assert_equal("acct_test_deauth", resp.stripe_user_id)
       end
     end
   end

data/test/stripe/order_return_test.rb

@@ -1,19 +1,21 @@
-require File.expand_path('../../test_helper', __FILE__)
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
 
 module Stripe
   class OrderReturnTest < Test::Unit::TestCase
     should "be listable" do
       order_returns = Stripe::OrderReturn.list
       assert_requested :get, "#{Stripe.api_base}/v1/order_returns"
-      assert order_returns.data.kind_of?(Array)
-      assert order_returns.data[0].kind_of?(Stripe::OrderReturn)
+      assert order_returns.data.is_a?(Array)
+      assert order_returns.data[0].is_a?(Stripe::OrderReturn)
     end
 
     should "be retrievable" do
       order_return = Stripe::OrderReturn.retrieve("orret_123")
       assert_requested :get,
-        "#{Stripe.api_base}/v1/order_returns/orret_123"
-      assert order_return.kind_of?(Stripe::OrderReturn)
+                       "#{Stripe.api_base}/v1/order_returns/orret_123"
+      assert order_return.is_a?(Stripe::OrderReturn)
     end
   end
 end

data/test/stripe/order_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 OrderTest < Test::Unit::TestCase
     should "be listable" do
       orders = Stripe::Order.list
       assert_requested :get, "#{Stripe.api_base}/v1/orders"
-      assert orders.data.kind_of?(Array)
-      assert orders.first.kind_of?(Stripe::Order)
+      assert orders.data.is_a?(Array)
+      assert orders.first.is_a?(Stripe::Order)
     end
 
     should "be retrievable" do
       order = Stripe::Order.retrieve("or_123")
       assert_requested :get, "#{Stripe.api_base}/v1/orders/or_123"
-      assert order.kind_of?(Stripe::Order)
+      assert order.is_a?(Stripe::Order)
     end
 
     should "be creatable" do
@@ -20,37 +22,60 @@ module Stripe
         currency: "USD"
       )
       assert_requested :post, "#{Stripe.api_base}/v1/orders"
-      assert order.kind_of?(Stripe::Order)
+      assert order.is_a?(Stripe::Order)
     end
 
     should "be saveable" do
       order = Stripe::Order.retrieve("or_123")
-      order.metadata['key'] = 'value'
+      order.metadata["key"] = "value"
       order.save
       assert_requested :post, "#{Stripe.api_base}/v1/orders/#{order.id}"
     end
 
     should "be updateable" do
-      order = Stripe::Order.update("or_123", metadata: { key: 'value' })
+      order = Stripe::Order.update("or_123", metadata: { key: "value" })
       assert_requested :post, "#{Stripe.api_base}/v1/orders/or_123"
-      assert order.kind_of?(Stripe::Order)
+      assert order.is_a?(Stripe::Order)
     end
 
     context "#pay" do
       should "pay an order" do
         order = Stripe::Order.retrieve("or_123")
-        order = order.pay(token: "tok_123")
-        assert order.kind_of?(Stripe::Order)
+        order = order.pay(source: "tok_123")
+        assert_requested :post, "#{Stripe.api_base}/v1/orders/#{order.id}/pay"
+        assert order.is_a?(Stripe::Order)
+      end
+
+      should "pay an order without additional arguments" do
+        order = Stripe::Order.retrieve("or_123")
+        order = order.pay
+        assert_requested :post, "#{Stripe.api_base}/v1/orders/#{order.id}/pay"
+        assert order.is_a?(Stripe::Order)
+      end
+    end
+
+    context ".pay" do
+      should "pay an order" do
+        order = Stripe::Order.pay("or_123", source: "tok_123")
+        assert_requested :post, "#{Stripe.api_base}/v1/orders/or_123/pay"
+        assert order.is_a?(Stripe::Order)
       end
     end
 
     context "#return_order" do
       should "return an order" do
         order = Stripe::Order.retrieve("or_123")
-        order = order.return_order(:orders => [
-          { parent: "sku_123" }
-        ])
-        assert order.kind_of?(Stripe::OrderReturn)
+        order_return = order.return_order({})
+        assert_requested :post, "#{Stripe.api_base}/v1/orders/#{order.id}/returns"
+        assert order_return.is_a?(Stripe::OrderReturn)
+      end
+    end
+
+    context ".return_order" do
+      should "return an order" do
+        order_return = Stripe::Order.return_order("or_123")
+        assert_requested :post, "#{Stripe.api_base}/v1/orders/or_123/returns"
+        assert order_return.is_a?(Stripe::OrderReturn)
       end
     end
   end

data/test/stripe/payment_intent_test.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class PaymentIntentTest < Test::Unit::TestCase
+    TEST_RESOURCE_ID = "pi_123"
+
+    should "be listable" do
+      payment_intents = Stripe::PaymentIntent.list
+      assert_requested :get, "#{Stripe.api_base}/v1/payment_intents"
+      assert payment_intents.data.is_a?(Array)
+      assert payment_intents.data[0].is_a?(Stripe::PaymentIntent)
+    end
+
+    should "be retrievable" do
+      payment_intent = Stripe::PaymentIntent.retrieve("pi_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/payment_intents/pi_123"
+      assert payment_intent.is_a?(Stripe::PaymentIntent)
+    end
+
+    should "be creatable" do
+      payment_intent = Stripe::PaymentIntent.create(
+        amount: 1234,
+        currency: "usd",
+        payment_method_types: ["card"]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/payment_intents"
+      assert payment_intent.is_a?(Stripe::PaymentIntent)
+    end
+
+    should "be saveable" do
+      payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", object: "payment_intent", metadata: {})
+      payment_intent.metadata["key"] = "value"
+      payment_intent.save
+      assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/#{payment_intent.id}"
+    end
+
+    should "be updateable" do
+      payment_intent = Stripe::PaymentIntent.update("pi_123", metadata: { foo: "bar" })
+
+      assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123"
+      assert payment_intent.is_a?(Stripe::PaymentIntent)
+    end
+
+    context "#cancel" do
+      should "cancel a payment_intent" do
+        payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", object: "payment_intent")
+        payment_intent = payment_intent.cancel
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123/cancel"
+        assert payment_intent.is_a?(Stripe::PaymentIntent)
+      end
+    end
+
+    context ".cancel" do
+      should "cancel a payment_intent" do
+        payment_intent = Stripe::PaymentIntent.cancel("pi_123")
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123/cancel"
+        assert payment_intent.is_a?(Stripe::PaymentIntent)
+      end
+    end
+
+    context "#capture" do
+      should "capture a payment_intent" do
+        payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", object: "payment_intent")
+        payment_intent = payment_intent.capture(
+          amount_to_capture: 1234
+        )
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123/capture"
+        assert payment_intent.is_a?(Stripe::PaymentIntent)
+      end
+    end
+
+    context ".capture" do
+      should "capture a payment_intent" do
+        payment_intent = Stripe::PaymentIntent.capture("pi_123", amount_to_capture: 1234)
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123/capture"
+        assert payment_intent.is_a?(Stripe::PaymentIntent)
+      end
+    end
+
+    context "#confirm" do
+      should "confirm a payment_intent" do
+        payment_intent = Stripe::PaymentIntent.construct_from(id: "pi_123", object: "payment_intent")
+        payment_intent = payment_intent.confirm(
+          payment_method: "pm_123"
+        )
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123/confirm"
+        assert payment_intent.is_a?(Stripe::PaymentIntent)
+      end
+    end
+
+    context ".confirm" do
+      should "confirm a payment_intent" do
+        payment_intent = Stripe::PaymentIntent.confirm("pi_123", payment_method: "pm_123")
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_intents/pi_123/confirm"
+        assert payment_intent.is_a?(Stripe::PaymentIntent)
+      end
+    end
+  end
+end

data/test/stripe/payment_method_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class PaymentMethodTest < Test::Unit::TestCase
+    should "be listable" do
+      payment_methods = Stripe::PaymentMethod.list(
+        customer: "cus_123",
+        type: "card"
+      )
+      assert_requested :get, "#{Stripe.api_base}/v1/payment_methods?customer=cus_123&type=card"
+      assert payment_methods.data.is_a?(Array)
+      assert payment_methods.first.is_a?(Stripe::PaymentMethod)
+    end
+
+    should "be retrievable" do
+      payment_method = Stripe::PaymentMethod.retrieve("pm_123")
+      assert_requested :get, "#{Stripe.api_base}/v1/payment_methods/pm_123"
+      assert payment_method.is_a?(Stripe::PaymentMethod)
+    end
+
+    should "be creatable" do
+      payment_method = Stripe::PaymentMethod.create(
+        type: "card"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/payment_methods"
+      assert payment_method.is_a?(Stripe::PaymentMethod)
+    end
+
+    should "be saveable" do
+      payment_method = Stripe::PaymentMethod.retrieve("pm_123")
+      payment_method.metadata["key"] = "value"
+      payment_method.save
+      assert_requested :post, "#{Stripe.api_base}/v1/payment_methods/#{payment_method.id}"
+    end
+
+    should "be updateable" do
+      payment_method = Stripe::PaymentMethod.update("pm_123", metadata: { key: "value" })
+      assert_requested :post, "#{Stripe.api_base}/v1/payment_methods/pm_123"
+      assert payment_method.is_a?(Stripe::PaymentMethod)
+    end
+
+    context "#attach" do
+      should "attach payment_method" do
+        payment_method = Stripe::PaymentMethod.construct_from(id: "pm_123", object: "payment_method")
+        payment_method = payment_method.attach(
+          customer: "cus_123"
+        )
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_methods/pm_123/attach"
+        assert payment_method.is_a?(Stripe::PaymentMethod)
+      end
+    end
+
+    context ".attach" do
+      should "attach payment_method" do
+        payment_method = Stripe::PaymentMethod.attach("pm_123", customer: "cus_123")
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_methods/pm_123/attach"
+        assert payment_method.is_a?(Stripe::PaymentMethod)
+      end
+    end
+
+    context "#detach" do
+      should "detach payment_method" do
+        payment_method = Stripe::PaymentMethod.construct_from(id: "pm_123", object: "payment_method")
+        payment_method = payment_method.detach
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_methods/pm_123/detach"
+        assert payment_method.is_a?(Stripe::PaymentMethod)
+      end
+    end
+
+    context ".detach" do
+      should "detach payment_method" do
+        payment_method = Stripe::PaymentMethod.detach("pm_123")
+
+        assert_requested :post, "#{Stripe.api_base}/v1/payment_methods/pm_123/detach"
+        assert payment_method.is_a?(Stripe::PaymentMethod)
+      end
+    end
+  end
+end

data/test/stripe/payout_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 PayoutTest < Test::Unit::TestCase
     should "be listable" do
       payouts = Stripe::Payout.list
       assert_requested :get, "#{Stripe.api_base}/v1/payouts"
-      assert payouts.data.kind_of?(Array)
-      assert payouts.data[0].kind_of?(Stripe::Payout)
+      assert payouts.data.is_a?(Array)
+      assert payouts.data[0].is_a?(Stripe::Payout)
     end
 
     should "be retrievable" do
       payout = Stripe::Payout.retrieve("tr_123")
       assert_requested :get, "#{Stripe.api_base}/v1/payouts/tr_123"
-      assert payout.kind_of?(Stripe::Payout)
+      assert payout.is_a?(Stripe::Payout)
     end
 
     should "be creatable" do
@@ -21,27 +23,34 @@ module Stripe
         currency: "USD"
       )
       assert_requested :post, "#{Stripe.api_base}/v1/payouts"
-      assert payout.kind_of?(Stripe::Payout)
+      assert payout.is_a?(Stripe::Payout)
     end
 
     should "be saveable" do
       payout = Stripe::Payout.retrieve("tr_123")
-      payout.metadata['key'] = 'value'
+      payout.metadata["key"] = "value"
       payout.save
       assert_requested :post, "#{Stripe.api_base}/v1/payouts/#{payout.id}"
     end
 
     should "be updateable" do
-      payout = Stripe::Payout.update("tr_123", metadata: {foo: 'bar'})
+      payout = Stripe::Payout.update("tr_123", metadata: { foo: "bar" })
       assert_requested :post, "#{Stripe.api_base}/v1/payouts/tr_123"
-      assert payout.kind_of?(Stripe::Payout)
+      assert payout.is_a?(Stripe::Payout)
     end
 
     context "#cancel" do
       should "cancel a payout" do
         payout = Stripe::Payout.retrieve("tr_123")
         payout = payout.cancel
-        assert payout.kind_of?(Stripe::Payout)
+        assert payout.is_a?(Stripe::Payout)
+      end
+    end
+
+    context ".cancel" do
+      should "cancel a payout" do
+        payout = Stripe::Payout.cancel("pm_123")
+        assert payout.is_a?(Stripe::Payout)
       end
     end
   end