bongloy 4.21.3

data/test/stripe/login_link_test.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require ::File.expand_path("../test_helper", __dir__)
+
+module Stripe
+  class LoginLinkTest < Test::Unit::TestCase
+    setup do
+      account_fixture = {
+        "id" => "acct_123",
+        "object" => "account",
+        "login_links" => {
+          "data" => [],
+          "has_more" => false,
+          "object" => "list",
+          "url" =>  "/v1/accounts/acct_123/login_links",
+        },
+      }
+      @account = Stripe::Account.construct_from(account_fixture)
+    end
+
+    should "not be retrievable" do
+      assert_raises NotImplementedError do
+        Stripe::LoginLink.retrieve("foo")
+      end
+    end
+
+    should "be creatable" do
+      stub_request(:post, "#{Stripe.api_base}/v1/accounts/#{@account.id}/login_links")
+        .to_return(body: JSON.generate(object: "login_link"))
+
+      login_link = @account.login_links.create
+      assert_requested :post,
+                       "#{Stripe.api_base}/v1/accounts/#{@account.id}/login_links"
+      assert login_link.is_a?(Stripe::LoginLink)
+    end
+  end
+end

data/test/stripe/oauth_test.rb

@@ -0,0 +1,88 @@
+# 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"
+    end
+
+    teardown do
+      Stripe.client_id = nil
+    end
+
+    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 = 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
+
+      should "optionally return an express path" do
+        uri_str = OAuth.authorize_url({}, express: true)
+
+        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
+
+    context ".token" do
+      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"))
+
+        resp = OAuth.token(grant_type: "authorization_code",
+                           code: "this_is_an_authorization_code")
+        assert_equal("sk_access_token", resp.access_token)
+      end
+    end
+
+    context ".deauthorize" do
+      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"))
+
+        resp = OAuth.deauthorize(stripe_user_id: "acct_test_deauth")
+        assert_equal("acct_test_deauth", resp.stripe_user_id)
+      end
+    end
+  end
+end

data/test/stripe/order_return_test.rb

@@ -0,0 +1,21 @@
+# 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.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.is_a?(Stripe::OrderReturn)
+    end
+  end
+end

data/test/stripe/order_test.rb

@@ -0,0 +1,82 @@
+# 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.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.is_a?(Stripe::Order)
+    end
+
+    should "be creatable" do
+      order = Stripe::Order.create(
+        currency: "USD"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/orders"
+      assert order.is_a?(Stripe::Order)
+    end
+
+    should "be saveable" do
+      order = Stripe::Order.retrieve("or_123")
+      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" })
+      assert_requested :post, "#{Stripe.api_base}/v1/orders/or_123"
+      assert order.is_a?(Stripe::Order)
+    end
+
+    context "#pay" do
+      should "pay an order" do
+        order = Stripe::Order.retrieve("or_123")
+        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_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
+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".freeze
+
+    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

@@ -0,0 +1,57 @@
+# 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.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.is_a?(Stripe::Payout)
+    end
+
+    should "be creatable" do
+      payout = Stripe::Payout.create(
+        amount: 100,
+        currency: "USD"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/payouts"
+      assert payout.is_a?(Stripe::Payout)
+    end
+
+    should "be saveable" do
+      payout = Stripe::Payout.retrieve("tr_123")
+      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" })
+      assert_requested :post, "#{Stripe.api_base}/v1/payouts/tr_123"
+      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.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
+end