stripe 1.30.3 → 2.0.0

data/test/stripe/customer_card_test.rb

@@ -2,62 +2,41 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class CustomerCardTest < Test::Unit::TestCase
-    CUSTOMER_CARD_URL = '/v1/customers/test_customer/sources/test_card'
+    FIXTURE = API_FIXTURES.fetch(:source)
 
-    def customer
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      Stripe::Customer.retrieve('test_customer')
+    setup do
+      @customer =
+        Stripe::Customer.retrieve(API_FIXTURES.fetch(:customer)[:id])
     end
 
-    should "customer cards should be listable" do
-      c = customer
-      @mock.expects(:get).once.returns(make_response(make_customer_card_array(customer.id)))
-      cards = c.sources.list(:object => "card").data
-      assert cards.kind_of? Array
-      assert cards[0].kind_of? Stripe::Card
+    should "be listable" do
+      sources = @customer.sources.list
+      assert sources.data.kind_of?(Array)
+      # because of the terrible :wildcard nature of sources, the API stub
+      # cannot currently replace this response with anything meaningful so we
+      # don't assert on the type of individual items like we do in other tests
     end
 
-    should "customer cards should have the correct url" do
-      c = customer
-      @mock.expects(:get).once.returns(make_response(make_card(
-        :id => 'test_card',
-        :customer => 'test_customer'
-      )))
-      card = c.sources.retrieve('card')
-      assert_equal CUSTOMER_CARD_URL, card.url
+    should "be creatable" do
+      card = @customer.sources.create(
+        source: API_FIXTURES.fetch(:token)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/customers/#{@customer.id}/sources"
+      assert card.kind_of?(Stripe::BankAccount)
     end
 
-    should "customer cards should be deletable" do
-      c = customer
-      @mock.expects(:get).once.returns(make_response(make_card))
-      @mock.expects(:delete).once.returns(make_response(make_card(:deleted => true)))
-      card = c.sources.retrieve('card')
-      card.delete
-      assert card.deleted
+    should "be deletable" do
+      card = Stripe::Card.construct_from(FIXTURE.merge(customer: @customer.id))
+      card = card.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/customers/#{@customer.id}/sources/#{FIXTURE[:id]}"
+      assert card.kind_of?(Stripe::Card)
     end
 
-    should "customer cards should be updateable" do
-      c = customer
-      @mock.expects(:get).once.returns(make_response(make_card(:exp_year => "2000")))
-      @mock.expects(:post).once.returns(make_response(make_card(:exp_year => "2100")))
-      card = c.sources.retrieve('card')
-      assert_equal "2000", card.exp_year
-      card.exp_year = "2100"
+    should "be saveable" do
+      card = Stripe::Card.construct_from(FIXTURE.merge(customer: @customer.id))
+      card.metadata['key'] = 'value'
       card.save
-      assert_equal "2100", card.exp_year
-    end
-
-    should "create should return a new customer card" do
-      c = customer
-      @mock.expects(:post).once.returns(make_response(make_card(:id => "test_card")))
-      card = c.sources.create(:source => "tok_41YJ05ijAaWaFS")
-      assert_equal "test_card", card.id
-    end
-
-    should "raise if accessing Stripe::Card.retrieve directly" do
-      assert_raises NotImplementedError do
-        Stripe::Card.retrieve "card_12345"
-      end
+      assert_requested :post, "#{Stripe.api_base}/v1/customers/#{@customer.id}/sources/#{FIXTURE[:id]}"
     end
   end
 end

data/test/stripe/customer_test.rb

@@ -2,87 +2,115 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class CustomerTest < Test::Unit::TestCase
-    should "customers should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_customer_array))
-      c = Stripe::Customer.list.data
-      assert c.kind_of? Array
-      assert c[0].kind_of? Stripe::Customer
-    end
+    FIXTURE = API_FIXTURES.fetch(:customer)
 
-    should "customers should be deletable" do
-      @mock.expects(:delete).once.returns(make_response(make_customer({:deleted => true})))
-      c = Stripe::Customer.new("test_customer")
-      c.delete
-      assert c.deleted
+    should "be listable" do
+      customers = Stripe::Customer.list
+      assert_requested :get, "#{Stripe.api_base}/v1/customers"
+      assert customers.data.kind_of?(Array)
+      assert customers.first.kind_of?(Stripe::Customer)
     end
 
-    should "customers should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_customer({:mnemonic => "foo"})))
-      @mock.expects(:post).once.returns(make_response(make_customer({:mnemonic => "bar"})))
-      c = Stripe::Customer.new("test_customer").refresh
-      assert_equal "foo", c.mnemonic
-      c.mnemonic = "bar"
-      c.save
-      assert_equal "bar", c.mnemonic
+    should "be retrievable" do
+      customer = Stripe::Customer.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/customers/#{FIXTURE[:id]}"
+      assert customer.kind_of?(Stripe::Customer)
     end
 
-    should "create should return a new customer" do
-      @mock.expects(:post).once.returns(make_response(make_customer))
-      c = Stripe::Customer.create
-      assert_equal "c_test_customer", c.id
+    should "be creatable" do
+      customer = Stripe::Customer.create
+      assert_requested :post, "#{Stripe.api_base}/v1/customers"
+      assert customer.kind_of?(Stripe::Customer)
     end
 
-    should "create_upcoming_invoice should create a new invoice" do
-      @mock.expects(:post).once.returns(make_response(make_invoice))
-      i = Stripe::Customer.new("test_customer").create_upcoming_invoice
-      assert_equal "c_test_customer", i.customer
+    should "be saveable" do
+      customer = Stripe::Customer.retrieve(FIXTURE[:id])
+      customer.metadata['key'] = 'value'
+      customer.save
+      assert_requested :post, "#{Stripe.api_base}/v1/customers/#{FIXTURE[:id]}"
     end
 
-    should "be able to update a customer's subscription" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      c = Stripe::Customer.retrieve("test_customer")
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/customers/c_test_customer/subscription" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
-      end.returns(make_response(make_subscription(:plan => 'silver')))
-      s = c.update_subscription({:plan => 'silver'})
-
-      assert_equal 'subscription', s.object
-      assert_equal 'silver', s.plan.identifier
+    should "be updateable" do
+      customer = Stripe::Customer.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/customers/#{FIXTURE[:id]}"
+      assert customer.kind_of?(Stripe::Customer)
     end
 
-    should "be able to cancel a customer's subscription" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      c = Stripe::Customer.retrieve("test_customer")
+    should "be deletable" do
+      customer = Stripe::Customer.retrieve(FIXTURE[:id])
+      customer = customer.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/customers/#{FIXTURE[:id]}"
+      assert customer.kind_of?(Stripe::Customer)
+    end
 
-      # Not an accurate response, but whatever
+    context "#create_subscription" do
+      should "create a new subscription" do
+        customer = Stripe::Customer.retrieve(FIXTURE[:id])
+        subscription = customer.create_subscription({:plan => 'silver'})
+        assert subscription.kind_of?(Stripe::Subscription)
+      end
+    end
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription?at_period_end=true", nil, nil).returns(make_response(make_subscription(:plan => 'silver')))
-      c.cancel_subscription({:at_period_end => 'true'})
+    context "#create_upcoming_invoice" do
+      should "create a new invoice" do
+        customer = Stripe::Customer.retrieve(FIXTURE[:id])
+        invoice = customer.create_upcoming_invoice
+        assert invoice.kind_of?(Stripe::Invoice)
+      end
+    end
 
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscription", nil, nil).returns(make_response(make_subscription(:plan => 'silver')))
-      c.cancel_subscription
+    context "#update_subscription" do
+      should "update a subscription" do
+        customer = Stripe::Customer.retrieve(FIXTURE[:id])
+
+        # deprecated API and not in schema
+        stub_request(:post, "#{Stripe.api_base}/v1/customers/#{customer.id}/subscription").
+          with(body: { plan: "silver" }).
+          to_return(body: JSON.generate(API_FIXTURES[:subscription]))
+        subscription = customer.update_subscription({:plan => 'silver'})
+        assert subscription.kind_of?(Stripe::Subscription)
+      end
     end
 
-    should "be able to create a subscription for a customer" do
-      c = Stripe::Customer.new("test_customer")
+    context "#cancel_subscription" do
+      should "cancel a subscription" do
+        customer = Stripe::Customer.retrieve(FIXTURE[:id])
+
+        # deprecated API and not in schema
+        stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{customer.id}/subscription").
+          with(query: { at_period_end: "true" }).
+          to_return(body: JSON.generate(API_FIXTURES[:subscription]))
+        subscription = customer.cancel_subscription({:at_period_end => 'true'})
+        assert subscription.kind_of?(Stripe::Subscription)
+      end
+    end
 
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/customers/test_customer/subscriptions" && api_key.nil? && CGI.parse(params) == {'plan' => ['silver']}
-      end.returns(make_response(make_subscription(:plan => 'silver')))
-      s = c.create_subscription({:plan => 'silver'})
+    context "#delete_discount" do
+      should "delete a discount" do
+        customer = Stripe::Customer.retrieve(FIXTURE[:id])
 
-      assert_equal 'subscription', s.object
-      assert_equal 'silver', s.plan.identifier
+        stub_request(:delete, "#{Stripe.api_base}/v1/customers/#{customer.id}/discount").
+          to_return(body: JSON.generate(API_FIXTURES[:discount]))
+        discount = customer.delete_discount
+        assert discount.kind_of?(Stripe::Customer)
+      end
     end
 
-    should "be able to delete a customer's discount" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      c = Stripe::Customer.retrieve("test_customer")
-
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/discount", nil, nil).returns(make_response(make_delete_discount_response))
-      c.delete_discount
-      assert_equal nil, c.discount
+    context "source field" do
+      should "allow setting source with token" do
+        c = Stripe::Customer.new("test_customer")
+        c.source = "tok_123"
+        assert_equal "tok_123", c.source
+      end
+
+      should "allow setting source with hash and set flag" do
+        c = Stripe::Customer.new("test_customer")
+        c.source = {
+          :object => 'card'
+        }
+        assert_equal true, c.source.save_with_parent
+      end
     end
   end
 end
+

data/test/stripe/dispute_test.rb

@@ -2,44 +2,41 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class DisputeTest < Test::Unit::TestCase
-    should "disputes should be retrievable" do
-      @mock.expects(:get).once.returns(make_response(make_dispute))
-      d = Stripe::Dispute.retrieve('dp_test_dispute')
-      assert d.kind_of?(Stripe::Dispute)
+    FIXTURE = API_FIXTURES.fetch(:dispute)
+
+    should "be listable" do
+      disputes = Stripe::Dispute.list
+      assert_requested :get, "#{Stripe.api_base}/v1/disputes"
+      assert disputes.data.kind_of?(Array)
+      assert disputes.first.kind_of?(Stripe::Dispute)
     end
 
-    should "disputes should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_dispute_array))
-      d = Stripe::Dispute.list
-      assert d.data.kind_of? Array
-      d.each do |dispute|
-        assert dispute.kind_of?(Stripe::Dispute)
-      end
+    should "be retrievable" do
+      dispute = Stripe::Dispute.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/disputes/#{FIXTURE[:id]}"
+      assert dispute.kind_of?(Stripe::Dispute)
     end
 
-    should "disputes should be closeable" do
-      @mock.expects(:get).never
-      @mock.expects(:post).with(
-        "#{Stripe.api_base}/v1/disputes/test_dispute/close",
-        nil,
-        ''
-      ).once.returns(make_response({:id => 'dp_test_dispute', :status => 'lost'}))
-      d = Stripe::Dispute.new('test_dispute')
-      d.close
+    should "be saveable" do
+      dispute = Stripe::Dispute.retrieve(FIXTURE[:id])
+      dispute.metadata['key'] = 'value'
+      dispute.save
+      assert_requested :post, "#{Stripe.api_base}/v1/disputes/#{FIXTURE[:id]}"
     end
 
-    should "disputes should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_dispute))
-      @mock.expects(:post).with(
-        "#{Stripe.api_base}/v1/disputes/dp_test_dispute",
-        nil,
-        'evidence[customer_name]=customer'
-      ).once.returns(make_response(make_dispute))
+    should "be updateable" do
+      dispute = Stripe::Dispute.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/disputes/#{FIXTURE[:id]}"
+      assert dispute.kind_of?(Stripe::Dispute)
+    end
 
-      d = Stripe::Dispute.new('test_dispute')
-      d.refresh
-      d.evidence['customer_name'] = 'customer'
-      d.save
+    context "#close" do
+      should "be closeable" do
+        dispute = Stripe::Dispute.retrieve(FIXTURE[:id])
+        dispute.close
+        assert_requested :post,
+          "#{Stripe.api_base}/v1/disputes/#{FIXTURE[:id]}/close"
+      end
     end
   end
 end

data/test/stripe/errors_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class StripeErrorTest < Test::Unit::TestCase
+    context "#to_s" do
+      should "convert to string" do
+        e = StripeError.new("message")
+        assert_equal "message", e.to_s
+
+        e = StripeError.new("message", http_status: 200)
+        assert_equal "(Status 200) message", e.to_s
+
+        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
+  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

@@ -0,0 +1,55 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class InvoiceItemTest < Test::Unit::TestCase
+    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 "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,39 +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
+    FIXTURE = API_FIXTURES.fetch(:invoice)
+
+    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 "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 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 "pay should pay an invoice" do
-      @mock.expects(:get).once.returns(make_response(make_invoice))
-      i = Stripe::Invoice.retrieve('in_test_invoice')
+    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
 
-      @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 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 "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'})
+    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
 
-      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))
+    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
 
-      i.pay
-      assert_equal nil, i.next_payment_attempt
+    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