stripe 4.18.1 → 5.42.0

data/test/stripe/issuing/authorization_test.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __dir__)
-
-module Stripe
-  module Issuing
-    class AuthorizationTest < Test::Unit::TestCase
-      should "be listable" do
-        authorizations = Stripe::Issuing::Authorization.list
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/authorizations"
-        assert authorizations.data.is_a?(Array)
-        assert authorizations.data[0].is_a?(Stripe::Issuing::Authorization)
-      end
-
-      should "be retrievable" do
-        authorization = Stripe::Issuing::Authorization.retrieve("iauth_123")
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/authorizations/iauth_123"
-        assert authorization.is_a?(Stripe::Issuing::Authorization)
-      end
-
-      should "be saveable" do
-        authorization = Stripe::Issuing::Authorization.retrieve("iauth_123")
-        authorization.metadata["key"] = "value"
-        authorization.save
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/authorizations/#{authorization.id}"
-        assert authorization.is_a?(Stripe::Issuing::Authorization)
-      end
-
-      should "be updateable" do
-        authorization = Stripe::Issuing::Authorization.update("iauth_123", metadata: { foo: "bar" })
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/authorizations/iauth_123"
-        assert authorization.is_a?(Stripe::Issuing::Authorization)
-      end
-
-      context ".approve" do
-        should "approve an authorization" do
-          payment_intent = Stripe::Issuing::Authorization.approve("iauth_123")
-
-          assert_requested :post, "#{Stripe.api_base}/v1/issuing/authorizations/iauth_123/approve"
-          assert payment_intent.is_a?(Stripe::Issuing::Authorization)
-        end
-      end
-
-      context "#approve" do
-        should "approve an authorization" do
-          authorization = Stripe::Issuing::Authorization.retrieve("iauth_123")
-          authorization.approve
-          assert_requested :post, "#{Stripe.api_base}/v1/issuing/authorizations/iauth_123/approve"
-          assert authorization.is_a?(Stripe::Issuing::Authorization)
-        end
-      end
-
-      context ".decline" do
-        should "decline an authorization" do
-          payment_intent = Stripe::Issuing::Authorization.decline("iauth_123")
-
-          assert_requested :post, "#{Stripe.api_base}/v1/issuing/authorizations/iauth_123/decline"
-          assert payment_intent.is_a?(Stripe::Issuing::Authorization)
-        end
-      end
-
-      context "#decline" do
-        should "decline an authorization" do
-          authorization = Stripe::Issuing::Authorization.retrieve("iauth_123")
-          authorization.decline
-          assert_requested :post, "#{Stripe.api_base}/v1/issuing/authorizations/iauth_123/decline"
-          assert authorization.is_a?(Stripe::Issuing::Authorization)
-        end
-      end
-    end
-  end
-end

data/test/stripe/issuing/card_test.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __dir__)
-
-module Stripe
-  module Issuing
-    class CardTest < Test::Unit::TestCase
-      should "be creatable" do
-        card = Stripe::Issuing::Card.create(
-          currency: "usd",
-          type: "physical"
-        )
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/cards"
-        assert card.is_a?(Stripe::Issuing::Card)
-      end
-
-      should "be listable" do
-        cards = Stripe::Issuing::Card.list
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/cards"
-        assert cards.data.is_a?(Array)
-        assert cards.data[0].is_a?(Stripe::Issuing::Card)
-      end
-
-      should "be retrievable" do
-        card = Stripe::Issuing::Card.retrieve("ic_123")
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/cards/ic_123"
-        assert card.is_a?(Stripe::Issuing::Card)
-      end
-
-      should "be saveable" do
-        card = Stripe::Issuing::Card.retrieve("ic_123")
-        card.metadata["key"] = "value"
-        card.save
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/cards/ic_123"
-        assert card.is_a?(Stripe::Issuing::Card)
-      end
-
-      should "be updateable" do
-        card = Stripe::Issuing::Card.update("ic_123", metadata: { foo: "bar" })
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/cards/ic_123"
-        assert card.is_a?(Stripe::Issuing::Card)
-      end
-
-      context "#details" do
-        should "retrieve a card's details" do
-          card_details = Stripe::Issuing::Card.details("ic_123")
-          assert_requested :get, "#{Stripe.api_base}/v1/issuing/cards/ic_123/details"
-          assert card_details.is_a?(Stripe::Issuing::CardDetails)
-        end
-      end
-
-      context ".details" do
-        should "retrieve a card's details" do
-          card = Stripe::Issuing::Card.retrieve("ic_123")
-          card_details = card.details
-          assert_requested :get, "#{Stripe.api_base}/v1/issuing/cards/ic_123/details"
-          assert card_details.is_a?(Stripe::Issuing::CardDetails)
-        end
-      end
-    end
-  end
-end

data/test/stripe/issuing/cardholder_test.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __dir__)
-
-module Stripe
-  module Issuing
-    class CardholderTest < Test::Unit::TestCase
-      should "be creatable" do
-        cardholder = Stripe::Issuing::Cardholder.create(
-          billing: {
-            address: {
-              city: "city",
-              country: "US",
-              line1: "line1",
-              postal_code: "postal_code",
-            },
-          },
-          name: "Jenny Rosen",
-          type: "individual"
-        )
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/cardholders"
-        assert cardholder.is_a?(Stripe::Issuing::Cardholder)
-      end
-
-      should "be listable" do
-        cardholders = Stripe::Issuing::Cardholder.list
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/cardholders"
-        assert cardholders.data.is_a?(Array)
-        assert cardholders.data[0].is_a?(Stripe::Issuing::Cardholder)
-      end
-
-      should "be retrievable" do
-        cardholder = Stripe::Issuing::Cardholder.retrieve("ich_123")
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/cardholders/ich_123"
-        assert cardholder.is_a?(Stripe::Issuing::Cardholder)
-      end
-
-      should "be saveable" do
-        cardholder = Stripe::Issuing::Cardholder.retrieve("ich_123")
-        cardholder.metadata["key"] = "value"
-        cardholder.save
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/cardholders/#{cardholder.id}"
-        assert cardholder.is_a?(Stripe::Issuing::Cardholder)
-      end
-
-      should "be updateable" do
-        cardholder = Stripe::Issuing::Cardholder.update("ich_123", metadata: { foo: "bar" })
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/cardholders/ich_123"
-        assert cardholder.is_a?(Stripe::Issuing::Cardholder)
-      end
-    end
-  end
-end

data/test/stripe/issuing/dispute_test.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __dir__)
-
-module Stripe
-  module Issuing
-    class DisputeTest < Test::Unit::TestCase
-      should "be creatable" do
-        dispute = Stripe::Issuing::Dispute.create(
-          reason: "fraudulent",
-          disputed_transaction: "ipi_123"
-        )
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/disputes"
-        assert dispute.is_a?(Stripe::Issuing::Dispute)
-      end
-
-      should "be listable" do
-        disputes = Stripe::Issuing::Dispute.list
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/disputes"
-        assert disputes.data.is_a?(Array)
-        assert disputes.data[0].is_a?(Stripe::Issuing::Dispute)
-      end
-
-      should "be retrievable" do
-        dispute = Stripe::Issuing::Dispute.retrieve("ich_123")
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/disputes/ich_123"
-        assert dispute.is_a?(Stripe::Issuing::Dispute)
-      end
-
-      should "be saveable" do
-        dispute = Stripe::Issuing::Dispute.retrieve("ich_123")
-        dispute.metadata["key"] = "value"
-        dispute.save
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/disputes/#{dispute.id}"
-        assert dispute.is_a?(Stripe::Issuing::Dispute)
-      end
-
-      should "be updateable" do
-        dispute = Stripe::Issuing::Dispute.update("ich_123", metadata: { foo: "bar" })
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/disputes/ich_123"
-        assert dispute.is_a?(Stripe::Issuing::Dispute)
-      end
-    end
-  end
-end

data/test/stripe/issuing/transaction_test.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../../test_helper", __dir__)
-
-module Stripe
-  module Issuing
-    class TransactionTest < Test::Unit::TestCase
-      should "be listable" do
-        stub_request(:get, "#{Stripe.api_base}/v1/issuing/transactions")
-          .to_return(body: JSON.generate(object: "list", data: [{ id: "ipi_123", object: "issuing.transaction" }]))
-
-        transactions = Stripe::Issuing::Transaction.list
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/transactions"
-        assert transactions.data.is_a?(Array)
-        assert transactions.data[0].is_a?(Stripe::Issuing::Transaction)
-      end
-
-      should "be retrievable" do
-        stub_request(:get, "#{Stripe.api_base}/v1/issuing/transactions/ipi_123")
-          .to_return(body: JSON.generate(id: "ipi_123", object: "issuing.transaction"))
-
-        transaction = Stripe::Issuing::Transaction.retrieve("ipi_123")
-        assert_requested :get, "#{Stripe.api_base}/v1/issuing/transactions/ipi_123"
-        assert transaction.is_a?(Stripe::Issuing::Transaction)
-      end
-
-      should "be saveable" do
-        stub_request(:post, "#{Stripe.api_base}/v1/issuing/transactions/ipi_123")
-          .to_return(body: JSON.generate(id: "ipi_123", object: "issuing.transaction"))
-
-        transaction = Stripe::Issuing::Transaction.construct_from(id: "ipi_123", object: "issuing.transaction", metadata: {})
-        transaction.metadata["key"] = "value"
-        transaction.save
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/transactions/#{transaction.id}"
-        assert transaction.is_a?(Stripe::Issuing::Transaction)
-      end
-
-      should "be updateable" do
-        stub_request(:post, "#{Stripe.api_base}/v1/issuing/transactions/ipi_123")
-          .to_return(body: JSON.generate(id: "ipi_123", object: "issuing.transaction"))
-
-        transaction = Stripe::Issuing::Transaction.update("ipi_123", metadata: { foo: "bar" })
-        assert_requested :post, "#{Stripe.api_base}/v1/issuing/transactions/ipi_123"
-        assert transaction.is_a?(Stripe::Issuing::Transaction)
-      end
-    end
-  end
-end

data/test/stripe/list_object_test.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require ::File.expand_path("../test_helper", __dir__)
-
-module Stripe
-  class ListObjectTest < Test::Unit::TestCase
-    should "provide .empty_list" do
-      list = Stripe::ListObject.empty_list
-      assert list.empty?
-    end
-
-    should "provide #count via enumerable" do
-      list = Stripe::ListObject.construct_from(data: [{ object: "charge" }])
-      assert_equal 1, list.count
-    end
-
-    should "provide #each" do
-      arr = [
-        { id: 1 },
-        { id: 2 },
-        { id: 3 },
-      ]
-      expected = Util.convert_to_stripe_object(arr, {})
-      list = Stripe::ListObject.construct_from(data: arr)
-      assert_equal expected, list.each.to_a
-    end
-
-    should "provide #auto_paging_each" do
-      arr = [
-        { id: 1 },
-        { id: 2 },
-        { id: 3 },
-      ]
-      expected = Util.convert_to_stripe_object(arr, {})
-
-      list = TestListObject.construct_from(data: [{ id: 1 }],
-                                           has_more: true,
-                                           url: "/things")
-      stub_request(:get, "#{Stripe.api_base}/things")
-        .with(query: { starting_after: "1" })
-        .to_return(body: JSON.generate(data: [{ id: 2 }, { id: 3 }], has_more: false))
-
-      assert_equal expected, list.auto_paging_each.to_a
-    end
-
-    should "provide #auto_paging_each that responds to a block" do
-      arr = [
-        { id: 1 },
-        { id: 2 },
-        { id: 3 },
-      ]
-      expected = Util.convert_to_stripe_object(arr, {})
-
-      list = TestListObject.construct_from(data: [{ id: 1 }],
-                                           has_more: true,
-                                           url: "/things")
-      stub_request(:get, "#{Stripe.api_base}/things")
-        .with(query: { starting_after: "1" })
-        .to_return(body: JSON.generate(data: [{ id: 2 }, { id: 3 }], has_more: false))
-
-      actual = []
-      list.auto_paging_each do |obj|
-        actual << obj
-      end
-
-      assert_equal expected, actual
-    end
-
-    should "provide #empty?" do
-      list = Stripe::ListObject.construct_from(data: [])
-      assert list.empty?
-      list = Stripe::ListObject.construct_from(data: [{}])
-      refute list.empty?
-    end
-
-    #
-    # next_page
-    #
-
-    should "fetch a next page through #next_page" do
-      list = TestListObject.construct_from(data: [{ id: 1 }],
-                                           has_more: true,
-                                           url: "/things")
-      stub_request(:get, "#{Stripe.api_base}/things")
-        .with(query: { starting_after: "1" })
-        .to_return(body: JSON.generate(data: [{ id: 2 }], has_more: false))
-      next_list = list.next_page
-      refute next_list.empty?
-    end
-
-    should "fetch a next page through #next_page and respect limit" do
-      list = TestListObject.construct_from(data: [{ id: 1 }],
-                                           has_more: true,
-                                           url: "/things")
-      list.filters = { expand: ["data.source"], limit: 3 }
-      stub_request(:get, "#{Stripe.api_base}/things")
-        .with(query: { "expand[]" => "data.source", "limit" => "3", "starting_after" => "1" })
-        .to_return(body: JSON.generate(data: [{ id: 2 }], has_more: false))
-      next_list = list.next_page
-      assert_equal({ expand: ["data.source"], limit: 3 }, next_list.filters)
-    end
-
-    should "fetch an empty page through #next_page" do
-      list = TestListObject.construct_from(data: [{ id: 1 }],
-                                           has_more: false,
-                                           url: "/things")
-      next_list = list.next_page
-      assert_equal Stripe::ListObject.empty_list, next_list
-    end
-
-    #
-    # previous_page
-    #
-
-    should "fetch a next page through #previous_page" do
-      list = TestListObject.construct_from(data: [{ id: 2 }],
-                                           url: "/things")
-      stub_request(:get, "#{Stripe.api_base}/things")
-        .with(query: { ending_before: "2" })
-        .to_return(body: JSON.generate(data: [{ id: 1 }]))
-      next_list = list.previous_page
-      refute next_list.empty?
-    end
-
-    should "fetch a next page through #previous_page and respect limit" do
-      list = TestListObject.construct_from(data: [{ id: 2 }],
-                                           url: "/things")
-      list.filters = { expand: ["data.source"], limit: 3 }
-      stub_request(:get, "#{Stripe.api_base}/things")
-        .with(query: { "expand[]" => "data.source", "limit" => "3", "ending_before" => "2" })
-        .to_return(body: JSON.generate(data: [{ id: 1 }]))
-      next_list = list.previous_page
-      assert_equal({ expand: ["data.source"], limit: 3 }, next_list.filters)
-    end
-
-    #
-    # backward compatibility
-    #
-
-    # note that the name #all is deprecated, as is using it fetch the next page
-    # in a list
-    should "be able to retrieve full lists given a listobject" do
-      c = Stripe::Charge.all
-      assert c.is_a?(Stripe::ListObject)
-      assert_equal("/v1/charges", c.resource_url)
-      all = c.all
-      assert all.is_a?(Stripe::ListObject)
-      assert_equal("/v1/charges", all.resource_url)
-      assert all.data.is_a?(Array)
-    end
-  end
-end
-
-# A helper class with a URL that allows us to try out pagination.
-class TestListObject < Stripe::ListObject
-end

data/test/stripe/login_link_test.rb

@@ -1,37 +0,0 @@
-# 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

@@ -1,88 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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