stripe 1.58.0 → 2.0.0

data/test/stripe/errors_test.rb

@@ -7,10 +7,10 @@ module Stripe
         e = StripeError.new("message")
         assert_equal "message", e.to_s
 
-        e = StripeError.new("message", 200)
+        e = StripeError.new("message", http_status: 200)
         assert_equal "(Status 200) message", e.to_s
 
-        e = StripeError.new("message", nil, nil, nil, { :request_id => "request-id" })
+        e = StripeError.new("message", http_status: nil, http_body: nil, json_body: nil, http_headers: { :request_id => "request-id" })
         assert_equal "(Request request-id) message", e.to_s
       end
     end

data/test/stripe/file_upload_test.rb

@@ -2,38 +2,46 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class FileUploadTest < Test::Unit::TestCase
-    should "create should return a new file" do
-      params = {
-        :purpose => "dispute_evidence",
-        :file => File.new(__FILE__),
-      }
+    # Note that these tests are written different from others because we
+    # don't have anything on the uploads service in our OpenAPI spec. This is
+    # something that should be looked into at some point. We may need to ship
+    # a separate spec for it though, so it's high effort with low reward for
+    # the time being.
+    FIXTURE = {
+      id: "fil_15ABpV2eZvKYlo2C7vu7XS5l",
+      object: "file_upload",
+    }.freeze
 
-      @mock.expects(:post).once.
-        with("#{Stripe.uploads_base}/v1/files", nil, params).
-        returns(make_response(make_file))
+    should "be listable" do
+      stub_request(:get, "#{Stripe.uploads_base}/v1/files").
+        to_return(body: JSON.generate({
+          data: [FIXTURE],
+          object: 'list',
+          resource_url: '/v1/files'
+        }))
 
-      f = Stripe::FileUpload.create(params)
-      assert_equal "fil_test_file", f.id
+      files = Stripe::FileUpload.list
+      assert files.data.kind_of?(Array)
+      assert files.data[0].kind_of?(Stripe::FileUpload)
     end
 
-    should "files should be retrievable" do
-      @mock.expects(:get).once.
-        with("#{Stripe.uploads_base}/v1/files/fil_test_file", nil, nil).
-        returns(make_response(make_file))
+    should "be retrievable" do
+      stub_request(:get, "#{Stripe.uploads_base}/v1/files/#{FIXTURE[:id]}").
+        to_return(body: JSON.generate(FIXTURE))
 
-      c = Stripe::FileUpload.new("fil_test_file")
-      c.refresh
-      assert_equal 1403047735, c.created
+      file = Stripe::FileUpload.retrieve(FIXTURE[:id])
+      assert file.kind_of?(Stripe::FileUpload)
     end
 
-    should "files should be listable" do
-      @mock.expects(:get).once.
-        with("#{Stripe.uploads_base}/v1/files", nil, nil).
-        returns(make_response(make_file_array))
+    should "be creatable" do
+      stub_request(:post, "#{Stripe.uploads_base}/v1/files").
+        to_return(body: JSON.generate(FIXTURE))
 
-      c = Stripe::FileUpload.list.data
-      assert c.kind_of? Array
-      assert c[0].kind_of? Stripe::FileUpload
+      file = Stripe::FileUpload.create(
+        purpose: "dispute_evidence",
+        file: File.new(__FILE__),
+      )
+      assert file.kind_of?(Stripe::FileUpload)
     end
   end
 end

data/test/stripe/invoice_item_test.rb

@@ -2,18 +2,54 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class InvoiceItemTest < Test::Unit::TestCase
-    should "retrieve should retrieve invoice items" do
-      @mock.expects(:get).once.returns(make_response(make_invoice_item))
-      ii = Stripe::InvoiceItem.retrieve('in_test_invoice_item')
-      assert_equal 'ii_test_invoice_item', ii.id
+    FIXTURE = API_FIXTURES.fetch(:invoice_item)
+
+    should "be listable" do
+      invoiceitems = Stripe::InvoiceItem.list
+      assert_requested :get, "#{Stripe.api_base}/v1/invoiceitems"
+      assert invoiceitems.data.kind_of?(Array)
+      assert invoiceitems.first.kind_of?(Stripe::InvoiceItem)
+    end
+
+    should "be retrievable" do
+      item = Stripe::InvoiceItem.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/invoiceitems/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::InvoiceItem)
+    end
+
+    should "be creatable" do
+      item = Stripe::InvoiceItem.create(
+        amount: 100,
+        currency: "USD",
+        customer: API_FIXTURES[:customer][:id]
+      )
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/invoiceitems"
+      assert item.kind_of?(Stripe::InvoiceItem)
+    end
+
+    should "be saveable" do
+      item = Stripe::InvoiceItem.retrieve(FIXTURE[:id])
+      item.metadata['key'] = 'value'
+      item.save
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/invoiceitems/#{FIXTURE[:id]}"
+    end
+
+    should "be updateable" do
+      item = Stripe::InvoiceItem.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/invoiceitems/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::InvoiceItem)
     end
 
-    should "invoice items should be updateable" do
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/invoiceitems/test_invoice_item', nil, 'metadata[foo]=bar').
-        returns(make_response(make_charge(metadata: {'foo' => 'bar'})))
-      ii = Stripe::InvoiceItem.update("test_invoice_item", metadata: {foo: 'bar'})
-      assert_equal('bar', ii.metadata['foo'])
+    should "be deletable" do
+      item = Stripe::InvoiceItem.retrieve(FIXTURE[:id])
+      item = item.delete
+      assert_requested :delete,
+        "#{Stripe.api_base}/v1/invoiceitems/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::InvoiceItem)
     end
   end
 end

data/test/stripe/invoice_test.rb

@@ -2,65 +2,65 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class InvoiceTest < Test::Unit::TestCase
-    should "retrieve should retrieve invoices" do
-      @mock.expects(:get).once.returns(make_response(make_invoice))
-      i = Stripe::Invoice.retrieve('in_test_invoice')
-      assert_equal 'in_test_invoice', i.id
-    end
+    FIXTURE = API_FIXTURES.fetch(:invoice)
 
-    should "create should create a new invoice" do
-      @mock.expects(:post).once.returns(make_response(make_invoice))
-      i = Stripe::Invoice.create
-      assert_equal "in_test_invoice", i.id
+    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 "pay should pay an invoice" do
-      @mock.expects(:get).once.returns(make_response(make_invoice))
-      i = Stripe::Invoice.retrieve('in_test_invoice')
-
-      @mock.expects(:post).once.with('https://api.stripe.com/v1/invoices/in_test_invoice/pay', nil, '').returns(make_response(make_paid_invoice))
-      i.pay
-      assert_equal nil, i.next_payment_attempt
+    should "be retrievable" do
+      invoice = Stripe::Invoice.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/invoices/#{FIXTURE[:id]}"
+      assert invoice.kind_of?(Stripe::Invoice)
     end
 
-    should "invoices should be updateable" do
-      @mock.expects(:post).once.
-        with("https://api.stripe.com/v1/invoices/test_invoice", nil, "metadata[foo]=bar").
-        returns(make_response(make_invoice(metadata: {foo: 'bar'})))
-      i = Stripe::Invoice.update("test_invoice", metadata: {foo: 'bar'})
-      assert_equal('bar', i.metadata['foo'])
+    should "be creatable" do
+      invoice = Stripe::Invoice.create(
+        :customer => API_FIXTURES[:customer][:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/invoices"
+      assert invoice.kind_of?(Stripe::Invoice)
     end
 
-    should "pay with extra opts should pay an invoice" do
-      @mock.expects(:get).once.returns(make_response(make_invoice))
-      i = Stripe::Invoice.retrieve('in_test_invoice', {:api_key => 'foobar'})
-
-      Stripe.expects(:execute_request).with do |opts|
-        opts[:url] == "#{Stripe.api_base}/v1/invoices/in_test_invoice/pay" &&
-          opts[:method] == :post &&
-          opts[:headers]['Authorization'] == 'Bearer foobar'
-      end.returns(make_response(make_paid_invoice))
-
-      i.pay
-      assert_equal nil, i.next_payment_attempt
+    should "be saveable" do
+      invoice = Stripe::Invoice.retrieve(FIXTURE[:id])
+      invoice.metadata['key'] = 'value'
+      invoice.save
+      assert_requested :post, "#{Stripe.api_base}/v1/invoices/#{FIXTURE[:id]}"
     end
 
-    should "be able to retrieve upcoming invoices" do
-      base = "#{Stripe.api_base}/v1/invoices/upcoming?"
-      cus_sub = "customer=c_test_customer&subscription=s_test_subscription&"
-      item0 = "subscription_items[][plan]=gold&subscription_items[][quantity]=1&"
-      item1 = "subscription_items[][plan]=silver&subscription_items[][quantity]=2"
-      @mock.expects(:get).once.with(base + cus_sub + item0 + item1, nil, nil).
-        returns(make_response(make_invoice(:customer => 'c_test_customer', :subscription => 's_test_subscription')))
+    should "be updateable" do
+      invoice = Stripe::Invoice.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/invoices/#{FIXTURE[:id]}"
+      assert invoice.kind_of?(Stripe::Invoice)
+    end
 
-      i = Stripe::Invoice.upcoming(
-        :customer => 'c_test_customer',
-        :subscription => 's_test_subscription',
-        :subscription_items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}]
-      )
+    context "#pay" do
+      should "pay invoice" do
+        invoice = Stripe::Invoice.retrieve(FIXTURE[:id])
+        invoice = invoice.pay
+        assert_requested :post,
+          "#{Stripe.api_base}/v1/invoices/#{FIXTURE[:id]}/pay"
+        assert invoice.kind_of?(Stripe::Invoice)
+      end
+    end
 
-      assert_equal 'c_test_customer', i.customer
-      assert_equal 's_test_subscription', i.subscription
+    context "#upcoming" do
+      should "retrieve upcoming invoices" do
+        invoice = Stripe::Invoice.upcoming(
+          customer: API_FIXTURES[:customer][:id],
+          subscription: API_FIXTURES[:subscription][:id]
+        )
+        assert_requested :get, "#{Stripe.api_base}/v1/invoices/upcoming",
+          query: {
+            customer: API_FIXTURES[:customer][:id],
+            subscription: API_FIXTURES[:subscription][:id]
+          }
+        assert invoice.kind_of?(Stripe::Invoice)
+      end
     end
   end
 end

data/test/stripe/list_object_test.rb

@@ -8,8 +8,10 @@ module Stripe
     end
 
     should "provide #count via enumerable" do
-      list = Stripe::ListObject.construct_from(make_charge_array)
-      assert_equal 3, list.count
+      list = Stripe::ListObject.construct_from({
+        data: [API_FIXTURES.fetch(:charge)]
+      })
+      assert_equal 1, list.count
     end
 
     should "provide #each" do
@@ -36,8 +38,9 @@ module Stripe
         :has_more => true,
         :url => "/things",
       })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
-        returns(make_response({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
+      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
@@ -55,8 +58,9 @@ module Stripe
         :has_more => true,
         :url => "/things",
       })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
-        returns(make_response({ :data => [{ :id => 2 }, { :id => 3}], :has_more => false }))
+      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|
@@ -83,8 +87,9 @@ module Stripe
         :has_more => true,
         :url => "/things",
       })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
-        returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
+      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
@@ -96,15 +101,9 @@ module Stripe
         :url => "/things",
       })
       list.filters = { :expand => ['data.source'], :limit => 3 }
-      @mock.expects(:get).with do |url, _, _|
-        u = URI.parse(url)
-        params = CGI.parse(u.query)
-        u.host == URI.parse(Stripe.api_base).host && u.path == "/things" && params == {
-          "expand[]"       => ["data.source"],
-          "limit"          => ["3"],
-          "starting_after" => ["1"],
-        }
-      end.returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
+      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
@@ -128,8 +127,9 @@ module Stripe
         :data => [{ :id => 2 }],
         :url => "/things",
       })
-      @mock.expects(:get).once.with("#{Stripe.api_base}/things?ending_before=2", nil, nil).
-        returns(make_response({ :data => [{ :id => 1 }] }))
+      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
@@ -140,17 +140,9 @@ module Stripe
         :url => "/things",
       })
       list.filters = { :expand => ['data.source'], :limit => 3 }
-      @mock.expects(:get).with do |url, _, _|
-        # apparently URI.parse in 1.8.7 doesn't support query parameters ...
-        url, query = url.split("?")
-        u = URI.parse(url)
-        params = CGI.parse(query)
-        u.host == URI.parse(Stripe.api_base).host && u.path == "/things" && params == {
-          "ending_before" => ["2"],
-          "expand[]"      => ["data.source"],
-          "limit"         => ["3"],
-        }
-      end.returns(make_response({ :data => [{ :id => 1 }] }))
+      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
@@ -162,7 +154,6 @@ module Stripe
     # 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
-      @mock.expects(:get).twice.returns(make_response(make_charge_array))
       c = Stripe::Charge.all
       assert c.kind_of?(Stripe::ListObject)
       assert_equal('/v1/charges', c.resource_url)

data/test/stripe/order_return_test.rb

@@ -2,24 +2,20 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class OrderReturnTest < Test::Unit::TestCase
-    should "returns should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_order_return_array))
-      returns = Stripe::OrderReturn.list
-      assert returns.data.kind_of?(Array)
-      returns.each do |ret|
-        assert ret.kind_of?(Stripe::OrderReturn)
-      end
-    end
+    FIXTURE = API_FIXTURES.fetch(:order_return)
 
-    should "returns should not be deletable" do
-      p = Stripe::OrderReturn.new("test_order")
-      assert_raises(NoMethodError) { p.delete }
+    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 "returns should be immutable" do
-      p = Stripe::OrderReturn.new("test_order")
-      p.items = []
-      assert_raises(NoMethodError) { p.save }
+    should "be retrievable" do
+      order_return = Stripe::OrderReturn.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/order_returns/#{FIXTURE[:id]}"
+      assert order_return.kind_of?(Stripe::OrderReturn)
     end
   end
 end

data/test/stripe/order_test.rb

@@ -2,71 +2,58 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class OrderTest < Test::Unit::TestCase
-    should "orders should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_order_array))
+    FIXTURE = API_FIXTURES.fetch(:order)
+
+    should "be listable" do
       orders = Stripe::Order.list
+      assert_requested :get, "#{Stripe.api_base}/v1/orders"
       assert orders.data.kind_of?(Array)
-      orders.each do |order|
-        assert order.kind_of?(Stripe::Order)
-      end
+      assert orders.first.kind_of?(Stripe::Order)
     end
 
-    should "orders should not be deletable" do
-      assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(make_response(make_order))
-        p = Stripe::Order.retrieve("test_order")
-        p.delete
-      end
+    should "be retrievable" do
+      order = Stripe::Order.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/orders/#{FIXTURE[:id]}"
+      assert order.kind_of?(Stripe::Order)
     end
 
-    should "orders should be saveable" do
-      @mock.expects(:get).once.returns(make_response(make_order))
-      @mock.expects(:post).once.returns(make_response(make_order))
-      p = Stripe::Order.new("test_order")
-      p.refresh
-      p.status = "fulfilled"
-      p.save
+    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 "orders should be updateable" do
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/orders/test_order', nil, 'status=fulfilled').
-        returns(make_response(make_order(status: 'fulfilled')))
-      ii = Stripe::Order.update("test_order", status: 'fulfilled')
-      assert_equal('fulfilled', ii.status)
+    should "be saveable" do
+      order = Stripe::Order.retrieve(FIXTURE[:id])
+      order.metadata['key'] = 'value'
+      order.save
+      assert_requested :post, "#{Stripe.api_base}/v1/orders/#{FIXTURE[:id]}"
     end
 
-    should "orders should allow metadata updates" do
-      @mock.expects(:get).once.returns(make_response(make_order))
-      @mock.expects(:post).once.returns(make_response(make_order))
-      p = Stripe::Order.new("test_order")
-      p.refresh
-      p.metadata['key'] = 'value'
-      p.save
+    should "be updateable" do
+      order = Stripe::Order.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/orders/#{FIXTURE[:id]}"
+      assert order.kind_of?(Stripe::Order)
     end
 
-    should "pay should pay an order" do
-      @mock.expects(:get).once.
-        returns(make_response(make_order(:id => 'or_test_order')))
-      order = Stripe::Order.retrieve('or_test_order')
-
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/orders/or_test_order/pay', nil, 'token=test_token').
-        returns(make_response(make_paid_order))
-      order.pay(:token => 'test_token')
-      assert_equal "paid", order.status
+    context "#pay" do
+      should "pay an order" do
+        order = Stripe::Order.retrieve(FIXTURE[:id])
+        order = order.pay(token: API_FIXTURES.fetch(:token)[:id])
+        assert order.kind_of?(Stripe::Order)
+      end
     end
 
-    should "return an order" do
-      @mock.expects(:get).once.
-        returns(make_response(make_order(:id => 'or_test_order')))
-      order = Stripe::Order.retrieve('or_test_order')
-
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/orders/or_test_order/returns', nil, 'items[][parent]=sku_foo').
-        returns(make_response(make_order_return({:order => order.id})))
-      order_return = order.return_order(:items => [{:parent => 'sku_foo'}])
-      assert_equal order.id, order_return.order
+    context "#return_order" do
+      should "return an order" do
+        order = Stripe::Order.retrieve(FIXTURE[:id])
+        order = order.return_order(:orders => [
+          { parent: API_FIXTURES.fetch(:sku)[:id] }
+        ])
+        assert order.kind_of?(Stripe::OrderReturn)
+      end
     end
   end
 end