stripe 3.3.1 → 5.38.0

data/test/stripe/invoice_test.rb

@@ -1,110 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class InvoiceTest < Test::Unit::TestCase
-    should "be listable" do
-      invoices = Stripe::Invoice.list
-      assert_requested :get, "#{Stripe.api_base}/v1/invoices"
-      assert invoices.data.kind_of?(Array)
-      assert invoices.first.kind_of?(Stripe::Invoice)
-    end
-
-    should "be retrievable" do
-      invoice = Stripe::Invoice.retrieve("in_123")
-      assert_requested :get, "#{Stripe.api_base}/v1/invoices/in_123"
-      assert invoice.kind_of?(Stripe::Invoice)
-    end
-
-    should "be creatable" do
-      invoice = Stripe::Invoice.create(
-        :customer => "cus_123"
-      )
-      assert_requested :post, "#{Stripe.api_base}/v1/invoices"
-      assert invoice.kind_of?(Stripe::Invoice)
-    end
-
-    should "be saveable" do
-      invoice = Stripe::Invoice.retrieve("in_123")
-      invoice.metadata['key'] = 'value'
-      invoice.save
-      assert_requested :post, "#{Stripe.api_base}/v1/invoices/#{invoice.id}"
-    end
-
-    should "be updateable" do
-      invoice = Stripe::Invoice.update("in_123", metadata: { key: 'value' })
-      assert_requested :post, "#{Stripe.api_base}/v1/invoices/in_123"
-      assert invoice.kind_of?(Stripe::Invoice)
-    end
-
-    context "#pay" do
-      should "pay invoice" do
-        invoice = Stripe::Invoice.retrieve("in_123")
-        invoice = invoice.pay
-        assert_requested :post,
-          "#{Stripe.api_base}/v1/invoices/#{invoice.id}/pay"
-        assert invoice.kind_of?(Stripe::Invoice)
-      end
-
-      should "pay invoice with a specific source" do
-        invoice = Stripe::Invoice.retrieve("in_123")
-        invoice = invoice.pay(
-          source: 'src_123',
-        )
-        assert_requested :post,
-          "#{Stripe.api_base}/v1/invoices/#{invoice.id}/pay",
-          body: {
-            source: 'src_123',
-          }
-        assert invoice.kind_of?(Stripe::Invoice)
-      end
-    end
-
-    context "#upcoming" do
-      should "retrieve upcoming invoices" do
-        invoice = Stripe::Invoice.upcoming(
-          customer: "cus_123",
-          subscription: "sub_123"
-        )
-        assert_requested :get, "#{Stripe.api_base}/v1/invoices/upcoming",
-          query: {
-            customer: "cus_123",
-            subscription: "sub_123"
-          }
-        assert invoice.kind_of?(Stripe::Invoice)
-      end
-
-      should "retrieve upcoming invoices with items" do
-        items = [{
-          plan: 'gold',
-          quantity: 2
-        }]
-
-        invoice = Stripe::Invoice.upcoming(
-          customer: "cus_123",
-          subscription_items: items
-        )
-
-        assert_requested :get, "#{Stripe.api_base}/v1/invoices/upcoming",
-          query: {
-            customer: "cus_123",
-            :'subscription_items[][plan]' => 'gold',
-            :'subscription_items[][quantity]' =>  2
-          }
-        assert invoice.kind_of?(Stripe::Invoice)
-      end
-
-      should "be callable with an empty string" do
-        invoice = Stripe::Invoice.upcoming(
-          coupon: '',
-          customer: "cus_123"
-        )
-        assert_requested :get, "#{Stripe.api_base}/v1/invoices/upcoming",
-          query: {
-            coupon: '',
-            customer: "cus_123"
-          }
-        assert invoice.kind_of?(Stripe::Invoice)
-      end
-    end
-  end
-end

data/test/stripe/list_object_test.rb

@@ -1,170 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-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.kind_of?(Stripe::ListObject)
-      assert_equal('/v1/charges', c.resource_url)
-      all = c.all
-      assert all.kind_of?(Stripe::ListObject)
-      assert_equal('/v1/charges', all.resource_url)
-      assert all.data.kind_of?(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,35 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-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.kind_of?(Stripe::LoginLink)
-    end
-  end
-end

data/test/stripe/oauth_test.rb

@@ -1,85 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-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
-    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,19 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-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)
-    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)
-    end
-  end
-end

data/test/stripe/order_test.rb

@@ -1,57 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-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)
-    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)
-    end
-
-    should "be creatable" do
-      order = Stripe::Order.create(
-        currency: "USD"
-      )
-      assert_requested :post, "#{Stripe.api_base}/v1/orders"
-      assert order.kind_of?(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.kind_of?(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)
-      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)
-      end
-    end
-  end
-end

data/test/stripe/payout_test.rb

@@ -1,48 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-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)
-    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)
-    end
-
-    should "be creatable" do
-      payout = Stripe::Payout.create(
-        amount: 100,
-        currency: "USD"
-      )
-      assert_requested :post, "#{Stripe.api_base}/v1/payouts"
-      assert payout.kind_of?(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.kind_of?(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)
-      end
-    end
-  end
-end

data/test/stripe/plan_test.rb

@@ -1,50 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class PlanTest < Test::Unit::TestCase
-    should "be listable" do
-      plans = Stripe::Plan.list
-      assert_requested :get, "#{Stripe.api_base}/v1/plans"
-      assert plans.data.kind_of?(Array)
-      assert plans.data[0].kind_of?(Stripe::Plan)
-    end
-
-    should "be retrievable" do
-      plan = Stripe::Plan.retrieve("sapphire-elite")
-      assert_requested :get, "#{Stripe.api_base}/v1/plans/sapphire-elite"
-      assert plan.kind_of?(Stripe::Plan)
-    end
-
-    should "be creatable" do
-      plan = Stripe::Plan.create(
-        amount: 5000,
-        interval: "month",
-        name: "Sapphire elite",
-        currency: "usd",
-        id: "sapphire-elite"
-      )
-      assert_requested :post, "#{Stripe.api_base}/v1/plans"
-      assert plan.kind_of?(Stripe::Plan)
-    end
-
-    should "be saveable" do
-      plan = Stripe::Plan.retrieve("sapphire-elite")
-      plan.metadata['key'] = 'value'
-      plan.save
-      assert_requested :post, "#{Stripe.api_base}/v1/plans/#{plan.id}"
-    end
-
-    should "be updateable" do
-      plan = Stripe::Plan.update("sapphire-elite", metadata: {foo: 'bar'})
-      assert_requested :post, "#{Stripe.api_base}/v1/plans/sapphire-elite"
-      assert plan.kind_of?(Stripe::Plan)
-    end
-
-    should "be deletable" do
-      plan = Stripe::Plan.retrieve("sapphire-elite")
-      plan = plan.delete
-      assert_requested :delete, "#{Stripe.api_base}/v1/plans/#{plan.id}"
-      assert plan.kind_of?(Stripe::Plan)
-    end
-  end
-end

data/test/stripe/product_test.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class ProductTest < Test::Unit::TestCase
-    should "be listable" do
-      products = Stripe::Product.list
-      assert_requested :get, "#{Stripe.api_base}/v1/products"
-      assert products.data.kind_of?(Array)
-      assert products.data[0].kind_of?(Stripe::Product)
-    end
-
-    should "be retrievable" do
-      product = Stripe::Product.retrieve("prod_123")
-      assert_requested :get, "#{Stripe.api_base}/v1/products/prod_123"
-      assert product.kind_of?(Stripe::Product)
-    end
-
-    should "be creatable" do
-      _ = Stripe::Product.create(
-        name: "My Product"
-      )
-      assert_requested :post, "#{Stripe.api_base}/v1/products"
-    end
-
-    should "be saveable" do
-      product = Stripe::Product.retrieve("prod_123")
-      product.metadata['key'] = 'value'
-      product.save
-      assert_requested :post, "#{Stripe.api_base}/v1/products/#{product.id}"
-    end
-
-    should "be updateable" do
-      product = Stripe::Product.update("prod_123", metadata: {foo: 'bar'})
-      assert_requested :post, "#{Stripe.api_base}/v1/products/prod_123"
-      assert product.kind_of?(Stripe::Product)
-    end
-
-    should "be deletable" do
-      product = Stripe::Product.retrieve("prod_123")
-      product = product.delete
-      assert_requested :delete, "#{Stripe.api_base}/v1/products/#{product.id}"
-      assert product.kind_of?(Stripe::Product)
-    end
-  end
-end

data/test/stripe/recipient_card_test.rb

@@ -1,44 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class RecipientCardTest < Test::Unit::TestCase
-    setup do
-      @recipient = Stripe::Recipient.retrieve("rp_123")
-    end
-
-    should "be listable" do
-      cards = @recipient.cards.list
-      assert cards.data.kind_of?(Array)
-      assert cards.data[0].kind_of?(Stripe::Card)
-    end
-
-    should "be creatable" do
-      card = @recipient.cards.create(
-        card: "tok_123"
-      )
-      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards"
-      assert card.kind_of?(Stripe::Card)
-    end
-
-    should "be deletable" do
-      card = Stripe::Card.construct_from({
-        id: "card_123",
-        recipient: @recipient.id
-      })
-      card = card.delete
-      assert_requested :delete, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards/card_123"
-      assert card.kind_of?(Stripe::Card)
-    end
-
-    should "be saveable" do
-      card = Stripe::Card.construct_from({
-        id: "card_123",
-        metadata: {},
-        recipient: @recipient.id
-      })
-      card.metadata['key'] = 'value'
-      card.save
-      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards/card_123"
-    end
-  end
-end