stripe 1.18.0 → 1.30.0

data/test/stripe/list_object_test.rb

@@ -2,8 +2,125 @@ 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(make_charge_array)
+      assert_equal 3, 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 })
+      @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 }))
+
+      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 })
+      @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 }))
+
+      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 })
+      @mock.expects(:get).once.with("#{Stripe.api_base}/things?starting_after=1", nil, nil).
+        returns(make_response({ :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 })
+      list.limit = 3
+      @mock.expects(:get).once.with("#{Stripe.api_base}/things?limit=3&starting_after=1", nil, nil).
+        returns(make_response({ :data => [{ :id => 2 }], :has_more => false }))
+      next_list = list.next_page
+      assert_equal 3, next_list.limit
+    end
+
+    should "fetch an empty page through #next_page" do
+      list = TestListObject.construct_from({ :data => [{ :id => 1 }], :has_more => false })
+      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 }] })
+      @mock.expects(:get).once.with("#{Stripe.api_base}/things?ending_before=2", nil, nil).
+        returns(make_response({ :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 }] })
+      list.limit = 3
+      @mock.expects(:get).once.with("#{Stripe.api_base}/things?ending_before=2&limit=3", nil, nil).
+        returns(make_response({ :data => [{ :id => 1 }] }))
+      next_list = list.previous_page
+      assert_equal 3, next_list.limit
+    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
-      @mock.expects(:get).twice.returns(test_response(test_charge_array))
+      @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.url)
@@ -13,4 +130,11 @@ module Stripe
       assert all.data.kind_of?(Array)
     end
   end
-end
+end
+
+# A helper class with a URL that allows us to try out pagination.
+class TestListObject < Stripe::ListObject
+  def url
+    "/things"
+  end
+end

data/test/stripe/metadata_test.rb

@@ -6,24 +6,39 @@ module Stripe
       @metadata_supported = {
         :charge => {
           :new => Stripe::Charge.method(:new),
-          :test => method(:test_charge),
-          :url => "/v1/charges/#{test_charge()[:id]}"
+          :test => method(:make_charge),
+          :url => "/v1/charges/#{make_charge()[:id]}"
         },
         :customer => {
           :new => Stripe::Customer.method(:new),
-          :test => method(:test_customer),
-          :url => "/v1/customers/#{test_customer()[:id]}"
+          :test => method(:make_customer),
+          :url => "/v1/customers/#{make_customer()[:id]}"
         },
         :recipient => {
           :new => Stripe::Recipient.method(:new),
-          :test => method(:test_recipient),
-          :url => "/v1/recipients/#{test_recipient()[:id]}"
+          :test => method(:make_recipient),
+          :url => "/v1/recipients/#{make_recipient()[:id]}"
         },
         :transfer => {
           :new => Stripe::Transfer.method(:new),
-          :test => method(:test_transfer),
-          :url => "/v1/transfers/#{test_transfer()[:id]}"
-        }
+          :test => method(:make_transfer),
+          :url => "/v1/transfers/#{make_transfer()[:id]}"
+        },
+        :product => {
+          :new => Stripe::Product.method(:new),
+          :test => method(:make_product),
+          :url => "/v1/products/#{make_product()[:id]}"
+        },
+        :order => {
+          :new => Stripe::Order.method(:new),
+          :test => method(:make_order),
+          :url => "/v1/orders/#{make_order()[:id]}"
+        },
+        :sku => {
+          :new => Stripe::SKU.method(:new),
+          :test => method(:make_sku),
+          :url => "/v1/skus/#{make_sku()[:id]}"
+        },
       }
 
       @base_url = 'https://api.stripe.com'
@@ -45,7 +60,7 @@ module Stripe
 
       if is_greater_than_ruby_1_9?
         check_metadata({:metadata => {:initial => 'true'}},
-                      'metadata[uuid]=6735&metadata[initial]=',
+                      'metadata[initial]=&metadata[uuid]=6735',
                       update_actions)
       end
     end
@@ -78,7 +93,7 @@ module Stripe
           obj.metadata['uuid'] = '6735'
         end
         params = {:metadata => {'type' => 'summer', 'uuid' => '6735'}}
-        curl_args = Stripe.uri_encode(params)
+        curl_args = Stripe::Util.encode_parameters(params)
         check_metadata({:metadata => {'type' => 'christmas'}},
                        curl_args,
                        update_actions)
@@ -92,11 +107,11 @@ module Stripe
         url = @base_url + methods[:url]
 
         initial_test_obj = test.call(initial_params)
-        @mock.expects(:get).once.returns(test_response(initial_test_obj))
+        @mock.expects(:get).once.returns(make_response(initial_test_obj))
 
         final_test_obj = test.call()
         @mock.expects(:post).once.
-          returns(test_response(final_test_obj)).
+          returns(make_response(final_test_obj)).
           with(url, nil, curl_args)
 
         obj = neu.call("test")

data/test/stripe/order_test.rb

@@ -0,0 +1,52 @@
+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))
+      orders = Stripe::Order.list
+      assert orders.data.kind_of?(Array)
+      orders.each do |order|
+        assert order.kind_of?(Stripe::Order)
+      end
+    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
+    end
+
+    should "orders should be updateable" 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
+    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
+    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
+    end
+  end
+end

data/test/stripe/product_test.rb

@@ -0,0 +1,41 @@
+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))
+      products = Stripe::Product.list
+      assert products.data.kind_of?(Array)
+      products.each do |product|
+        assert product.kind_of?(Stripe::Product)
+      end
+    end
+
+    should "products should not be deletable" do
+      assert_raises NoMethodError do
+        @mock.expects(:get).once.returns(make_response(make_product))
+        p = Stripe::Product.retrieve("test_product")
+        p.delete
+      end
+    end
+
+    should "products should be updateable" 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
+    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
+    end
+
+  end
+end

data/test/stripe/recipient_card_test.rb

@@ -5,21 +5,21 @@ module Stripe
     RECIPIENT_CARD_URL = '/v1/recipients/test_recipient/cards/test_card'
 
     def recipient
-      @mock.expects(:get).once.returns(test_response(test_recipient))
+      @mock.expects(:get).once.returns(make_response(make_recipient))
       Stripe::Recipient.retrieve('test_recipient')
     end
 
     should "recipient cards should be listable" do
       c = recipient
-      @mock.expects(:get).once.returns(test_response(test_card_array(recipient.id)))
-      cards = c.cards.all.data
+      @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
     end
 
     should "recipient cards should have the correct url" do
       c = recipient
-      @mock.expects(:get).once.returns(test_response(test_card(
+      @mock.expects(:get).once.returns(make_response(make_card(
         :id => 'test_card',
         :recipient => 'test_recipient'
       )))
@@ -29,8 +29,8 @@ module Stripe
 
     should "recipient cards should be deletable" do
       c = recipient
-      @mock.expects(:get).once.returns(test_response(test_card))
-      @mock.expects(:delete).once.returns(test_response(test_card(:deleted => true)))
+      @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
@@ -38,8 +38,8 @@ module Stripe
 
     should "recipient cards should be updateable" do
       c = recipient
-      @mock.expects(:get).once.returns(test_response(test_card(:exp_year => "2000")))
-      @mock.expects(:post).once.returns(test_response(test_card(:exp_year => "2100")))
+      @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"
@@ -49,7 +49,7 @@ module Stripe
 
     should "create should return a new recipient card" do
       c = recipient
-      @mock.expects(:post).once.returns(test_response(test_card(:id => "test_card")))
+      @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
     end

data/test/stripe/refund_test.rb

@@ -3,44 +3,52 @@ require File.expand_path('../../test_helper', __FILE__)
 module Stripe
   class RefundTest < Test::Unit::TestCase
     should "refunds should be listable" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
+      @mock.expects(:get).
+        with("#{Stripe.api_base}/v1/refunds", nil, nil).
+        once.returns(make_response(make_refund_array))
 
-      charge = Stripe::Charge.retrieve('test_charge')
+      refunds = Stripe::Refund.list
 
-      assert charge.refunds.first.kind_of?(Stripe::Refund)
+      assert refunds.first.kind_of?(Stripe::Refund)
     end
 
     should "refunds should be refreshable" do
-      @mock.expects(:get).twice.returns(test_response(test_charge), test_response(test_refund(:id => 'refreshed_refund')))
+      @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')))
 
-      charge = Stripe::Charge.retrieve('test_charge')
-      refund = charge.refunds.first
+      refund = Stripe::Refund.retrieve('test_refund')
       refund.refresh
 
       assert_equal 'refreshed_refund', refund.id
     end
 
     should "refunds should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      @mock.expects(:post).once.returns(test_response(test_refund(:metadata => {'key' => 'value'})))
+      @mock.expects(:get).
+        with("#{Stripe.api_base}/v1/refunds/get_refund", nil, nil).
+        once.returns(make_response(make_refund(:id => 'save_refund')))
 
-      charge = Stripe::Charge.retrieve('test_charge')
-      refund = charge.refunds.first
+      @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']
 
-      refund.metadata['key'] = 'valu'
+      refund.metadata['key'] = 'value'
       refund.save
 
       assert_equal 'value', refund.metadata['key']
     end
 
     should "create should return a new refund" do
-      @mock.expects(:get).once.returns(test_response(test_charge))
-      @mock.expects(:post).once.returns(test_response(test_refund(:id => 'test_new_refund')))
+      @mock.expects(:post).
+        with("#{Stripe.api_base}/v1/refunds", nil, 'charge=test_charge').
+        once.returns(make_response(make_refund(:id => 'test_new_refund')))
 
-      charge = Stripe::Charge.retrieve('test_charge')
-      refund = charge.refunds.create(:amount => 20)
+      refund = Stripe::Refund.create(:charge => 'test_charge')
       assert_equal 'test_new_refund', refund.id
     end
   end

data/test/stripe/reversal_test.rb

@@ -0,0 +1,47 @@
+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))
+
+      transfer = Stripe::Transfer.retrieve('test_transfer')
+
+      assert transfer.reversals.first.kind_of?(Stripe::Reversal)
+    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
+    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
+
+      assert_equal nil, reversal.metadata['key']
+
+      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
+    end
+  end
+end

data/test/stripe/sku_test.rb

@@ -0,0 +1,24 @@
+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")))
+      skus = Stripe::SKU.list
+      assert skus.data.kind_of? Array
+      skus.each do |sku|
+        assert sku.kind_of?(Stripe::SKU)
+      end
+    end
+
+    should "SKUs should not be deletable" do
+      assert_raises NoMethodError do
+        @mock.expects(:get).once.returns(make_response(make_sku))
+        p = Stripe::SKU.retrieve("test_product")
+        p.delete
+      end
+    end
+
+  end
+end

data/test/stripe/stripe_object_test.rb

@@ -2,26 +2,87 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class StripeObjectTest < Test::Unit::TestCase
-    should "implement #respond_to correctly" do
+    should "implement #==" do
+      obj1 = Stripe::StripeObject.construct_from({ :id => 1, :foo => "bar" })
+      obj2 = Stripe::StripeObject.construct_from({ :id => 1, :foo => "bar" })
+      obj3 = Stripe::StripeObject.construct_from({ :id => 1, :foo => "rab" })
+
+      assert obj1 == obj2
+      refute obj1 == obj3
+    end
+
+    should "implement #deleted?" do
+      obj = Stripe::StripeObject.construct_from({})
+      refute obj.deleted?
+
+      obj = Stripe::StripeObject.construct_from({ :deleted => false })
+      refute obj.deleted?
+
+      obj = Stripe::StripeObject.construct_from({ :deleted => true })
+      assert obj.deleted?
+    end
+
+    should "implement #respond_to" do
       obj = Stripe::StripeObject.construct_from({ :id => 1, :foo => 'bar' })
       assert obj.respond_to?(:id)
       assert obj.respond_to?(:foo)
       assert !obj.respond_to?(:baz)
     end
 
+    should "marshal be insensitive to strings vs. symbols when constructin" do
+      obj = Stripe::StripeObject.construct_from({ :id => 1, 'name' => 'Stripe' })
+      assert_equal 1, obj[:id]
+      assert_equal 'Stripe', obj[:name]
+    end
+
     should "marshal a stripe object correctly" do
-      obj = Stripe::StripeObject.construct_from({ :id => 1, :name => 'Stripe' }, 'apikey')
+      obj = Stripe::StripeObject.construct_from({ :id => 1, :name => 'Stripe' }, {:api_key => 'apikey'})
       m = Marshal.load(Marshal.dump(obj))
       assert_equal 1, m.id
       assert_equal 'Stripe', m.name
-      assert_equal 'apikey', m.api_key
+      expected_hash = {:api_key => 'apikey'}
+      assert_equal expected_hash, m.instance_variable_get('@opts')
     end
 
     should "recursively call to_hash on its values" do
-      nested = Stripe::StripeObject.construct_from({ :id => 7, :foo => 'bar' })
-      obj = Stripe::StripeObject.construct_from({ :id => 1, :nested => nested })
-      expected_hash = { :id => 1, :nested => { :id => 7, :foo => 'bar' } }
+      nested_hash = { :id => 7, :foo => 'bar' }
+      nested = Stripe::StripeObject.construct_from(nested_hash)
+      obj = Stripe::StripeObject.construct_from({ :id => 1, :nested => nested, :list => [nested] })
+      expected_hash = { :id => 1, :nested => nested_hash, :list => [nested_hash] }
       assert_equal expected_hash, obj.to_hash
     end
+
+    should "assign question mark accessors for booleans" do
+      obj = Stripe::StripeObject.construct_from({ :id => 1, :bool => true, :not_bool => 'bar' })
+      assert obj.respond_to?(:bool?)
+      assert obj.bool?
+      refute obj.respond_to?(:not_bool?)
+    end
+
+    should "mass assign values with #update_attributes" do
+      obj = Stripe::StripeObject.construct_from({ :id => 1, :name => 'Stripe' })
+      obj.update_attributes(:name => 'STRIPE')
+      assert_equal "STRIPE", obj.name
+
+      # unfortunately, we even assign unknown properties to duplicate the
+      # behavior that we currently have via magic accessors with
+      # method_missing
+      obj.update_attributes(:unknown => 'foo')
+      assert_equal "foo", obj.unknown
+    end
+
+    should "warn that #refresh_from is deprecated" do
+      old_stderr = $stderr
+      $stderr = StringIO.new
+      begin
+        obj = Stripe::StripeObject.construct_from({})
+        obj.refresh_from({}, {})
+        message = "NOTE: Stripe::StripeObject#refresh_from is " +
+          "deprecated; use #update_attributes instead"
+        assert_match Regexp.new(message), $stderr.string
+      ensure
+        $stderr = old_stderr
+      end
+    end
   end
 end