stripe 1.58.0 → 2.0.0

data/test/stripe/plan_test.rb

@@ -2,30 +2,51 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class PlanTest < Test::Unit::TestCase
-    should "plans should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_plan_array))
+    FIXTURE = API_FIXTURES.fetch(:plan)
+
+    should "be listable" do
       plans = Stripe::Plan.list
+      assert_requested :get, "#{Stripe.api_base}/v1/plans"
       assert plans.data.kind_of?(Array)
-      plans.each do |plan|
-        assert plan.kind_of?(Stripe::Plan)
-      end
+      assert plans.data[0].kind_of?(Stripe::Plan)
+    end
+
+    should "be retrievable" do
+      plan = Stripe::Plan.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+      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(FIXTURE[:id])
+      plan.metadata['key'] = 'value'
+      plan.save
+      assert_requested :post, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
     end
 
-    should "plans should be saveable" do
-      @mock.expects(:get).once.returns(make_response(make_plan))
-      @mock.expects(:post).once.returns(make_response(make_plan))
-      p = Stripe::Plan.new("test_plan")
-      p.refresh
-      p.metadata['foo'] = 'bar'
-      p.save
+    should "be updateable" do
+      plan = Stripe::Plan.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+      assert plan.kind_of?(Stripe::Plan)
     end
 
-    should "plans should be updateable" do
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/plans/test_plan', nil, 'metadata[foo]=bar').
-        returns(make_response(make_plan(metadata: {foo: 'bar'})))
-      p = Stripe::Plan.update("test_plan", metadata: {foo: 'bar'})
-      assert_equal('bar', p.metadata['foo'])
+    should "be deletable" do
+      plan = Stripe::Plan.retrieve(FIXTURE[:id])
+      plan = plan.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/plans/#{FIXTURE[:id]}"
+      assert plan.kind_of?(Stripe::Plan)
     end
   end
 end

data/test/stripe/product_test.rb

@@ -2,50 +2,46 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ProductTest < Test::Unit::TestCase
-    should "products should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_product_array))
+    FIXTURE = API_FIXTURES.fetch(:product)
+
+    should "be listable" do
       products = Stripe::Product.list
+      assert_requested :get, "#{Stripe.api_base}/v1/products"
       assert products.data.kind_of?(Array)
-      products.each do |product|
-        assert product.kind_of?(Stripe::Product)
-      end
+      assert products.data[0].kind_of?(Stripe::Product)
     end
 
-    should "products should be deletable" do
-      @mock.expects(:get).once.returns(make_response(make_product))
-      @mock.expects(:delete).once.
-        returns(make_response(make_product(:deleted => true)))
-
-      p = Stripe::Product.retrieve("test_product")
-      p.delete
-      assert p.deleted
+    should "be retrievable" do
+      product = Stripe::Product.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
+      assert product.kind_of?(Stripe::Product)
     end
 
-    should "products should be saveable" do
-      @mock.expects(:get).once.returns(make_response(make_product))
-      @mock.expects(:post).once.returns(make_response(make_product))
-      p = Stripe::Product.new("test_product")
-      p.refresh
-      p.description = "New product description"
-      p.save
+    should "be creatable" do
+      _ = Stripe::Product.create(
+        name: "My Product"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/products"
     end
 
-    should "products should be updateable" do
-      @mock.expects(:post).once.
-        with('https://api.stripe.com/v1/products/test_product', nil, 'description=update').
-        returns(make_response(make_product(description: 'update')))
-      p = Stripe::Product.update("test_product", description: 'update')
-      assert_equal('update', p.description)
+    should "be saveable" do
+      product = Stripe::Product.retrieve(FIXTURE[:id])
+      product.metadata['key'] = 'value'
+      product.save
+      assert_requested :post, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
     end
 
-    should "products should allow metadata updates" do
-      @mock.expects(:get).once.returns(make_response(make_product))
-      @mock.expects(:post).once.returns(make_response(make_product))
-      p = Stripe::Product.new("test_product")
-      p.refresh
-      p.metadata['key'] = 'value'
-      p.save
+    should "be updateable" do
+      product = Stripe::Product.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
+      assert product.kind_of?(Stripe::Product)
     end
 
+    should "be deletable" do
+      product = Stripe::Product.retrieve(FIXTURE[:id])
+      product = product.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/products/#{FIXTURE[:id]}"
+      assert product.kind_of?(Stripe::Product)
+    end
   end
 end

data/test/stripe/recipient_card_test.rb

@@ -2,56 +2,39 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class RecipientCardTest < Test::Unit::TestCase
-    RECIPIENT_CARD_URL = '/v1/recipients/test_recipient/cards/test_card'
+    FIXTURE = API_FIXTURES.fetch(:source)
 
-    def recipient
-      @mock.expects(:get).once.returns(make_response(make_recipient))
-      Stripe::Recipient.retrieve('test_recipient')
+    setup do
+      @recipient =
+        Stripe::Recipient.retrieve(API_FIXTURES.fetch(:transfer_recipient)[:id])
     end
 
-    should "recipient cards should be listable" do
-      c = recipient
-      @mock.expects(:get).once.returns(make_response(make_recipient_card_array(recipient.id)))
-      cards = c.cards.list.data
-      assert cards.kind_of? Array
-      assert cards[0].kind_of? Stripe::Card
+    should "be listable" do
+      cards = @recipient.cards.list
+      assert cards.data.kind_of?(Array)
+      assert cards.data[0].kind_of?(Stripe::Token)
     end
 
-    should "recipient cards should have the correct resource url" do
-      c = recipient
-      @mock.expects(:get).once.returns(make_response(make_card(
-        :id => 'test_card',
-        :recipient => 'test_recipient'
-      )))
-      card = c.cards.retrieve('card')
-      assert_equal RECIPIENT_CARD_URL, card.resource_url
+    should "be creatable" do
+      card = @recipient.cards.create(
+        card: API_FIXTURES.fetch(:token)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards"
+      assert card.kind_of?(Stripe::Token)
     end
 
-    should "recipient cards should be deletable" do
-      c = recipient
-      @mock.expects(:get).once.returns(make_response(make_card))
-      @mock.expects(:delete).once.returns(make_response(make_card(:deleted => true)))
-      card = c.cards.retrieve('card')
-      card.delete
-      assert card.deleted
+    should "be deletable" do
+      card = Stripe::Card.construct_from(FIXTURE.merge(recipient: @recipient.id))
+      card = card.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards/#{FIXTURE[:id]}"
+      assert card.kind_of?(Stripe::Card)
     end
 
-    should "recipient cards should be updateable" do
-      c = recipient
-      @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.cards.retrieve('card')
-      assert_equal "2000", card.exp_year
-      card.exp_year = "2100"
+    should "be saveable" do
+      card = Stripe::Card.construct_from(FIXTURE.merge(recipient: @recipient.id))
+      card.metadata['key'] = 'value'
       card.save
-      assert_equal "2100", card.exp_year
-    end
-
-    should "create should return a new recipient card" do
-      c = recipient
-      @mock.expects(:post).once.returns(make_response(make_card(:id => "test_card")))
-      card = c.cards.create(:card => "tok_41YJ05ijAaWaFS")
-      assert_equal "test_card", card.id
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{@recipient.id}/cards/#{FIXTURE[:id]}"
     end
   end
 end

data/test/stripe/recipient_test.rb

@@ -2,19 +2,48 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class RecipientTest < Test::Unit::TestCase
+    FIXTURE = API_FIXTURES.fetch(:transfer_recipient)
 
-    should "recipient should be retrievable" do
-      @mock.expects(:get).once.returns(make_response(make_recipient))
-      r = Stripe::Recipient.retrieve('test_recipient')
-      assert_equal 'rp_test_recipient', r.id
+    should "be listable" do
+      recipients = Stripe::Recipient.list
+      assert_requested :get, "#{Stripe.api_base}/v1/recipients"
+      assert recipients.data.kind_of?(Array)
+      assert recipients.data[0].kind_of?(Stripe::Recipient)
     end
 
-    should "recipient should be updateable" do
-      @mock.expects(:post).once.
-        with("https://api.stripe.com/v1/recipients/test_recipient", nil, "metadata[foo]=bar").
-        returns(make_response(make_recipient(metadata: {foo: 'bar'})))
-      r = Stripe::Recipient.update('test_recipient', metadata: {foo: 'bar'})
-      assert_equal 'bar', r.metadata['foo']
+    should "be retrievable" do
+      recipient = Stripe::Recipient.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+
+    should "be creatable" do
+      recipient = Stripe::Recipient.create(
+        name: "Noah Jackson",
+        type: "individual"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+
+    should "be saveable" do
+      recipient = Stripe::Recipient.retrieve(FIXTURE[:id])
+      recipient.metadata['key'] = 'value'
+      recipient.save
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+    end
+
+    should "be updateable" do
+      recipient = Stripe::Recipient.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+      assert recipient.kind_of?(Stripe::Recipient)
+    end
+
+    should "be deletable" do
+      recipient = Stripe::Recipient.retrieve(FIXTURE[:id])
+      recipient = recipient.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/recipients/#{FIXTURE[:id]}"
+      assert recipient.kind_of?(Stripe::Recipient)
     end
   end
 end

data/test/stripe/refund_test.rb

@@ -2,63 +2,38 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class RefundTest < Test::Unit::TestCase
-    should "refunds should be listable" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/refunds", nil, nil).
-        once.returns(make_response(make_refund_array))
+    FIXTURE = API_FIXTURES.fetch(:refund)
 
+    should "be listable" do
       refunds = Stripe::Refund.list
-
+      assert_requested :get, "#{Stripe.api_base}/v1/refunds"
+      assert refunds.data.kind_of?(Array)
       assert refunds.first.kind_of?(Stripe::Refund)
     end
 
-    should "refunds should be refreshable" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/refunds/test_refund", nil, nil).
-        twice.returns(make_response(make_refund(:id => 'test_refund')),
-                       make_response(make_refund(:id => 'refreshed_refund')))
-
-      refund = Stripe::Refund.retrieve('test_refund')
-      refund.refresh
-
-      assert_equal 'refreshed_refund', refund.id
+    should "be retrievable" do
+      refund = Stripe::Refund.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/refunds/#{FIXTURE[:id]}"
+      assert refund.kind_of?(Stripe::Refund)
     end
 
-    should "refunds should be saveable" do
-      @mock.expects(:get).
-        with("#{Stripe.api_base}/v1/refunds/get_refund", nil, nil).
-        once.returns(make_response(make_refund(:id => 'save_refund')))
-
-      @mock.expects(:post).
-        with("#{Stripe.api_base}/v1/refunds/save_refund", nil, 'metadata[key]=value').
-        once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
-
-      refund = Stripe::Refund.retrieve('get_refund')
-
-      assert_equal nil, refund.metadata['key']
+    should "be creatable" do
+      refund = Stripe::Refund.create(:charge => API_FIXTURES[:charge][:id])
+      assert_requested :post, "#{Stripe.api_base}/v1/refunds"
+      assert refund.kind_of?(Stripe::Refund)
+    end
 
+    should "be saveable" do
+      refund = Stripe::Refund.retrieve(FIXTURE[:id])
       refund.metadata['key'] = 'value'
       refund.save
-
-      assert_equal 'value', refund.metadata['key']
-    end
-
-    should "refunds should be updateable" do
-      @mock.expects(:post).
-        with("#{Stripe.api_base}/v1/refunds/update_refund", nil, 'metadata[key]=value').
-        once.returns(make_response(make_refund(:metadata => {'key' => 'value'})))
-
-      refund = Stripe::Refund.update('update_refund', metadata: {key: 'value'})
-      assert_equal 'value', refund.metadata['key']
+      assert_requested :post, "#{Stripe.api_base}/v1/refunds/#{FIXTURE[:id]}"
     end
 
-    should "create should return a new refund" do
-      @mock.expects(:post).
-        with("#{Stripe.api_base}/v1/refunds", nil, 'charge=test_charge').
-        once.returns(make_response(make_refund(:id => 'test_new_refund')))
-
-      refund = Stripe::Refund.create(:charge => 'test_charge')
-      assert_equal 'test_new_refund', refund.id
+    should "be updateable" do
+      refund = Stripe::Refund.update(FIXTURE[:id], metadata: { key: 'value' })
+      assert_requested :post, "#{Stripe.api_base}/v1/refunds/#{FIXTURE[:id]}"
+      assert refund.kind_of?(Stripe::Refund)
     end
   end
 end

data/test/stripe/reversal_test.rb

@@ -2,46 +2,42 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ReversalTest < Test::Unit::TestCase
-    should "reversals should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
+    FIXTURE = API_FIXTURES.fetch(:transfer_reversal)
 
-      transfer = Stripe::Transfer.retrieve('test_transfer')
-
-      assert transfer.reversals.first.kind_of?(Stripe::Reversal)
+    setup do
+      @transfer = Stripe::Transfer.retrieve(API_FIXTURES.fetch(:transfer)[:id])
     end
 
-    should "reversals should be refreshable" do
-      @mock.expects(:get).twice.returns(make_response(make_transfer), make_response(make_reversal(:id => 'refreshed_reversal')))
-
-      transfer = Stripe::Transfer.retrieve('test_transfer')
-      reversal = transfer.reversals.first
-      reversal.refresh
-
-      assert_equal 'refreshed_reversal', reversal.id
+    should "be listable" do
+      reversals = @transfer.reversals.list
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals"
+      assert reversals.data.kind_of?(Array)
+      assert reversals.data[0].kind_of?(Stripe::Reversal)
     end
 
-    should "reversals should be updateable" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
-      @mock.expects(:post).once.returns(make_response(make_reversal(:metadata => {'key' => 'value'})))
-
-      transfer = Stripe::Transfer.retrieve('test_transfer')
-      reversal = transfer.reversals.first
+    should "be retrievable" do
+      reversal = @transfer.reversals.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals/#{FIXTURE[:id]}"
+      assert reversal.kind_of?(Stripe::Reversal)
+    end
 
-      assert_equal nil, reversal.metadata['key']
+    should "be creatable" do
+      reversal = @transfer.reversals.create(
+        amount: 100
+      )
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals"
+      assert reversal.kind_of?(Stripe::Reversal)
+    end
 
+    should "be saveable" do
+      reversal = @transfer.reversals.retrieve(FIXTURE[:id])
       reversal.metadata['key'] = 'value'
       reversal.save
-
-      assert_equal 'value', reversal.metadata['key']
-    end
-
-    should "create should return a new reversal" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
-      @mock.expects(:post).once.returns(make_response(make_reversal(:id => 'test_new_reversal')))
-
-      transfer = Stripe::Transfer.retrieve('test_transfer')
-      reversals = transfer.reversals.create(:amount => 20)
-      assert_equal 'test_new_reversal', reversals.id
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/transfers/#{@transfer.id}/reversals/#{FIXTURE[:id]}"
     end
   end
 end

data/test/stripe/sku_test.rb

@@ -2,32 +2,49 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class SKUTest < Test::Unit::TestCase
-    should "SKUs should be listable" do
-      @mock.expects(:get).once.
-        returns(make_response(make_sku_array("test_product")))
+    FIXTURE = API_FIXTURES.fetch(:sku)
+
+    should "be listable" do
       skus = Stripe::SKU.list
-      assert skus.data.kind_of? Array
-      skus.each do |sku|
-        assert sku.kind_of?(Stripe::SKU)
-      end
+      assert_requested :get, "#{Stripe.api_base}/v1/skus"
+      assert skus.data.kind_of?(Array)
+      assert skus.data[0].kind_of?(Stripe::SKU)
     end
 
-    should "SKUs should be updateable" do
-      @mock.expects(:post).once.
-        with("#{Stripe.api_base}/v1/skus/test_sku", nil, 'metadata[foo]=bar').
-        returns(make_response(make_sku(:metadata => {foo: 'bar'})))
-      s = Stripe::SKU.update("test_sku", metadata: {foo: 'bar'})
-      assert_equal 'bar', s.metadata['foo']
+    should "be retrievable" do
+      sku = Stripe::SKU.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/skus/#{FIXTURE[:id]}"
+      assert sku.kind_of?(Stripe::SKU)
     end
 
-    should "SKUs should be deletable" do
-      @mock.expects(:get).once.returns(make_response(make_sku))
-      @mock.expects(:delete).once.returns(make_response(make_sku(:deleted => true)))
+    should "be creatable" do
+      _ = Stripe::SKU.create(
+        currency: "USD",
+        inventory: { type: "finite", quantity: 500 },
+        price: 100,
+        product: API_FIXTURES.fetch(:product)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/skus"
+    end
 
-      s = Stripe::SKU.retrieve("test_sku")
-      s.delete
-      assert s.deleted
+    should "be saveable" do
+      sku = Stripe::SKU.retrieve(FIXTURE[:id])
+      sku.metadata['key'] = 'value'
+      sku.save
+      assert_requested :post, "#{Stripe.api_base}/v1/skus/#{FIXTURE[:id]}"
     end
 
+    should "be updateable" do
+      sku = Stripe::SKU.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/skus/#{FIXTURE[:id]}"
+      assert sku.kind_of?(Stripe::SKU)
+    end
+
+    should "be deletable" do
+      sku = Stripe::SKU.retrieve(FIXTURE[:id])
+      sku = sku.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/skus/#{FIXTURE[:id]}"
+      assert sku.kind_of?(Stripe::SKU)
+    end
   end
 end