stripe 1.58.0 → 2.0.0

data/test/stripe/stripe_object_test.rb

@@ -116,9 +116,13 @@ module Stripe
 
       # customer comes with a `sources` list that makes a convenient object to
       # perform tests on
-      customer = Stripe::Customer.construct_from(make_customer, opts)
+      obj = Stripe::StripeObject.construct_from({
+        sources: [
+          {}
+        ]
+      }, opts)
 
-      source = customer.sources.first
+      source = obj.sources.first
       # Pulling `@opts` as an instance variable here is not ideal, but it's
       # important enough argument that the test here is worth it. we should
       # consider exposing it publicly on a future pull (and possibly renaming

data/test/stripe/stripe_response_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Stripe
+  class StripeResponseTest < Test::Unit::TestCase
+    context ".from_faraday_hash" do
+      should "converts to StripeResponse" do
+        body = '{"foo": "bar"}'
+        headers = { "Request-Id" => "request-id" }
+
+        http_resp = {
+          body: body,
+          headers: headers,
+          status: 200,
+        }
+
+        resp = StripeResponse.from_faraday_hash(http_resp)
+
+        assert_equal JSON.parse(body, symbolize_names: true), resp.data
+        assert_equal body, resp.http_body
+        assert_equal headers, resp.http_headers
+        assert_equal 200, resp.http_status
+        assert_equal "request-id", resp.request_id
+      end
+    end
+
+    context ".from_faraday_response" do
+      should "converts to StripeResponse" do
+        body = '{"foo": "bar"}'
+        headers = { "Request-Id" => "request-id" }
+
+        env = Faraday::Env.from(
+          :status => 200, :body => body,
+          :response_headers => headers)
+        http_resp = Faraday::Response.new(env)
+
+        resp = StripeResponse.from_faraday_response(http_resp)
+
+        assert_equal JSON.parse(body, symbolize_names: true), resp.data
+        assert_equal body, resp.http_body
+        assert_equal headers, resp.http_headers
+        assert_equal 200, resp.http_status
+        assert_equal "request-id", resp.request_id
+      end
+    end
+  end
+end

data/test/stripe/subscription_item_test.rb

@@ -2,75 +2,53 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class SubscriptionItemTest < Test::Unit::TestCase
-    should "subscription items should be retrievable" do
-      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscription_items/si_test_subscription_item", nil, nil).
-        returns(make_response(make_subscription_item))
-
-      sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
-
-      assert sub_item.kind_of?(Stripe::SubscriptionItem)
+    FIXTURE = API_FIXTURES.fetch(:subscription_item)
+
+    should "be listable" do
+      items = Stripe::SubscriptionItem.list(
+        subscription: API_FIXTURES.fetch(:subscription)[:id]
+      )
+      assert_requested :get, "#{Stripe.api_base}/v1/subscription_items",
+        query: { subscription: API_FIXTURES.fetch(:subscription)[:id] }
+      assert items.data.kind_of?(Array)
+      assert items.data[0].kind_of?(Stripe::SubscriptionItem)
     end
 
-    should "subscription items should be listable" do
-      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscription_items?subscription=s_test_subscription&limit=3", nil, nil).
-        returns(make_response(make_subscription_item_array))
-      sub_items = Stripe::SubscriptionItem.list(:subscription => 's_test_subscription', :limit => 3).data
-
-      assert sub_items.kind_of? Array
-      assert sub_items[0].kind_of? Stripe::SubscriptionItem
+    should "be retrievable" do
+      item = Stripe::SubscriptionItem.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::SubscriptionItem)
     end
 
-    should "subscription items should be deletable" do
-      @mock.expects(:get).once.returns(make_response(make_subscription_item))
-      sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
-
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}", nil, nil).
-        returns(make_response(make_subscription_item))
-      sub_item.delete
+    should "be creatable" do
+      item = Stripe::SubscriptionItem.create(
+        item: 'silver',
+        plan: API_FIXTURES.fetch(:plan)[:id],
+        quantity: 3,
+        subscription: API_FIXTURES.fetch(:subscription)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/subscription_items"
+      assert item.kind_of?(Stripe::SubscriptionItem)
     end
 
-    should "subscription items should be updateable" do
-      sid = 'si_test_subscription_item'
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscription_items/#{sid}" &&
-          api_key.nil? &&
-          CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
-      end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
-
-      sub_item = Stripe::SubscriptionItem.update(sid, {:plan => 'silver', :quantity => 3})
-
-      assert_equal 'silver', sub_item.plan.id
-      assert_equal 3, sub_item.quantity
+    should "be saveable" do
+      item = Stripe::SubscriptionItem.retrieve(FIXTURE[:id])
+      item.quantity = 4
+      item.save
+      assert_requested :post, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
     end
 
-    should "subscription items should be saveable" do
-      @mock.expects(:get).once.returns(make_response(make_subscription_item))
-      sub_item = Stripe::SubscriptionItem.retrieve('si_test_subscription_item')
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscription_items/#{sub_item.id}" &&
-          api_key.nil? &&
-          CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
-      end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
-
-      sub_item.plan = 'silver'
-      sub_item.quantity = 3
-      sub_item.save
-
-      assert_equal 'silver', sub_item.plan.id
-      assert_equal 3, sub_item.quantity
+    should "be updateable" do
+      item = Stripe::SubscriptionItem.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::SubscriptionItem)
     end
 
-    should "create should return a new subscription item" do
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscription_items" && api_key.nil? &&
-          CGI.parse(params) == {'plan' => ['silver'], 'quantity' => ['3']}
-      end.returns(make_response(make_subscription_item(:plan => 'silver', :quantity => 3)))
-
-      sub_item = Stripe::SubscriptionItem.create(:plan => 'silver', :quantity => 3)
-
-      assert_equal 'silver', sub_item.plan.id
-      assert_equal 3, sub_item.quantity
+    should "be deletable" do
+      item = Stripe::SubscriptionItem.retrieve(FIXTURE[:id])
+      item = item.delete
+      assert_requested :delete, "#{Stripe.api_base}/v1/subscription_items/#{FIXTURE[:id]}"
+      assert item.kind_of?(Stripe::SubscriptionItem)
     end
   end
 end

data/test/stripe/subscription_test.rb

@@ -2,195 +2,59 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class SubscriptionTest < Test::Unit::TestCase
-    should "subscriptions should be retrievable by customer" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      customer = Stripe::Customer.retrieve('c_test_customer')
+    FIXTURE = API_FIXTURES.fetch(:subscription)
 
-      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions/s_test_subscription", nil, nil).returns(make_response(make_subscription(:id => 's_test_subscription')))
-      _ = customer.subscriptions.retrieve('s_test_subscription')
+    should "be listable" do
+      subscriptions = Stripe::Subscription.list
+      assert_requested :get, "#{Stripe.api_base}/v1/subscriptions"
+      assert subscriptions.data.kind_of?(Array)
+      assert subscriptions.data[0].kind_of?(Stripe::Subscription)
     end
 
-    should "subscriptions should be listable by customer" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      customer = Stripe::Customer.retrieve('c_test_customer')
-
-      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions", nil, nil).returns(make_response(make_customer_subscription_array('c_test_customer')))
-      subs = customer.subscriptions.all()
-
-      assert subs.kind_of?(Stripe::ListObject)
-      assert subs.data.kind_of?(Array)
-      assert subs.data[0].kind_of? Stripe::Subscription
-    end
-
-    should "subscriptions should be creatable by customer" do
-      @mock.expects(:get).once.returns(make_response(make_customer))
-      customer = Stripe::Customer.retrieve('c_test_customer')
-
-      @mock.expects(:post).once.with("#{Stripe.api_base}/v1/customers/c_test_customer/subscriptions", nil, 'plan=silver').returns(make_response(make_subscription(:id => 'test_new_subscription')))
-      subscription = customer.subscriptions.create(:plan => 'silver')
-
-      assert_equal 'test_new_subscription', subscription.id
-    end
-
-    should "subscriptions should be retrievable" do
-      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscriptions/s_test_subscription", nil, nil).returns(make_response(make_subscription))
-      sub = Stripe::Subscription.retrieve('s_test_subscription')
-
-      assert sub.kind_of?(Stripe::Subscription)
-    end
-
-    should "subscriptions should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_subscription_array))
-      subs = Stripe::Subscription.list.data
-
-      assert subs.kind_of? Array
-      assert subs[0].kind_of? Stripe::Subscription
-    end
-
-    should "subscriptions should be listable with filters" do
-      @mock.expects(:get).once.with("#{Stripe.api_base}/v1/subscriptions?customer=c_test_customer&limit=3&plan=gold", nil, nil).returns(make_response(make_subscription_array))
-      subs = Stripe::Subscription.all(:customer => 'c_test_customer', :limit => 3, :plan => 'gold')
-
-      assert subs.kind_of?(Stripe::ListObject)
-      assert subs.data.kind_of?(Array)
-      assert subs.data[0].kind_of? Stripe::Subscription
-    end
-
-    should "subscriptions should be refreshable" do
-      @mock.expects(:get).twice.returns(make_response(make_subscription(:id => 'refreshed_subscription')))
-
-      sub = Stripe::Subscription.retrieve('s_test_subscription')
-      sub.refresh
-
-      assert_equal 'refreshed_subscription', sub.id
-    end
-
-    should "subscriptions should be deletable" do
-      @mock.expects(:get).once.returns(make_response(make_subscription))
-      sub = Stripe::Subscription.retrieve('s_test_subscription')
-
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscriptions/#{sub.id}?at_period_end=true", nil, nil).returns(make_response(make_subscription))
-      sub.delete :at_period_end => true
-
-      @mock.expects(:delete).once.with("#{Stripe.api_base}/v1/subscriptions/#{sub.id}", nil, nil).returns(make_response(make_subscription))
-      sub.delete
-    end
-
-    should "subscriptions should be updateable" do
-      sid = 's_test_subscription'
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" && api_key.nil? && CGI.parse(params) == {'status' => ['active']}
-      end.returns(make_response(make_subscription(:status => 'active')))
-
-      sub = Stripe::Subscription.update(sid, :status => 'active')
-
-      assert_equal 'active', sub.status
+    should "be retrievable" do
+      subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+      assert_requested :get,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
+      assert subscription.kind_of?(Stripe::Subscription)
     end
 
-    should "subscription items should be updateable" do
-      sid = 's_test_subscription'
-      items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" &&
-          api_key.nil? &&
-          CGI.parse(params) == {
-            'items[0][plan]' => ['gold'],
-            'items[0][quantity]' => ['1'],
-            'items[1][plan]' => ['silver'],
-            'items[1][quantity]' => ['2'],
-          }
-      end.returns(make_response(make_subscription(:items => items)))
-
-      sub = Stripe::Subscription.update(sid, :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
-
-      assert_equal 'gold', sub.items.data[0].plan.id
-      assert_equal 1, sub.items.data[0].quantity
-      assert_equal 'silver', sub.items.data[1].plan.id
-      assert_equal 2, sub.items.data[1].quantity
-    end
-
-    should "subscription items should be updateable with hash" do
-      sid = 's_test_subscription'
-      items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscriptions/#{sid}" &&
-          api_key.nil? &&
-          CGI.parse(params) == {
-            'items[0][plan]' => ['gold'],
-            'items[0][quantity]' => ['1'],
-            'items[1][plan]' => ['silver'],
-            'items[1][quantity]' => ['2'],
-          }
-      end.returns(make_response(make_subscription(:items => items)))
-
-      sub = Stripe::Subscription.update(sid, :items => {'0' => {:plan => 'gold', :quantity =>1}, '1' => {:plan => 'silver', :quantity =>2}})
-
-      assert_equal 'gold', sub.items.data[0].plan.id
-      assert_equal 1, sub.items.data[0].quantity
-      assert_equal 'silver', sub.items.data[1].plan.id
-      assert_equal 2, sub.items.data[1].quantity
+    should "be creatable" do
+      subscription = Stripe::Subscription.create(
+        customer: API_FIXTURES.fetch(:customer)[:id]
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/subscriptions"
+      assert subscription.kind_of?(Stripe::Subscription)
     end
 
-    should "subscriptions should be saveable" do
-      @mock.expects(:get).once.returns(make_response(make_subscription))
-      sub = Stripe::Subscription.retrieve('s_test_subscription')
-      assert_equal 'trialing', sub.status
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscriptions/#{sub.id}" && api_key.nil? && CGI.parse(params) == {'status' => ['active']}
-      end.returns(make_response(make_subscription(:status => 'active')))
-
-      sub.status = 'active'
-      sub.save
-
-      assert_equal 'active', sub.status
+    should "be saveable" do
+      subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+      subscription.metadata['key'] = 'value'
+      subscription.save
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
     end
 
-    should "create should return a new subscription" do
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscriptions" && api_key.nil? && CGI.parse(params) == {'customer' => ['c_test_customer'], 'plan' => ['gold']}
-      end.returns(make_response(make_subscription(:plan => 'gold', :id => 'test_new_subscription')))
-
-      sub = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer')
-
-      assert_equal 'test_new_subscription', sub.id
-      assert_equal 'gold', sub.plan.identifier
+    should "be updateable" do
+      subscription = Stripe::Subscription.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
+      assert subscription.kind_of?(Stripe::Subscription)
     end
 
-    should "create with items should return a new subscription" do
-      items = {:data => [{:plan => {:id =>'gold'}, :quantity => 1}, {:plan => {:id =>'silver'}, :quantity => 2}]}
-
-      @mock.expects(:post).once.with do |url, api_key, params|
-        url == "#{Stripe.api_base}/v1/subscriptions" &&
-          api_key.nil? &&
-          CGI.parse(params) == {
-            'customer' => ['c_test_customer'],
-            'items[0][plan]' => ['gold'],
-            'items[0][quantity]' => ['1'],
-            'items[1][plan]' => ['silver'],
-            'items[1][quantity]' => ['2'],
-          }
-      end.returns(make_response(make_subscription(:items => items, :id => 'test_new_subscription')))
-
-      sub = Stripe::Subscription.create(:customer => 'c_test_customer', :items => [{:plan => 'gold', :quantity =>1}, {:plan => 'silver', :quantity =>2}])
-
-      assert_equal 'test_new_subscription', sub.id
-      assert_equal 'gold', sub.items.data[0].plan.id
-      assert_equal 1, sub.items.data[0].quantity
-      assert_equal 'silver', sub.items.data[1].plan.id
-      assert_equal 2, sub.items.data[1].quantity
+    should "be deletable" do
+      subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+      subscription = subscription.delete
+      assert_requested :delete,
+        "#{Stripe.api_base}/v1/subscriptions/#{FIXTURE[:id]}"
+      assert subscription.kind_of?(Stripe::Subscription)
     end
 
-    should "be able to delete a subscriptions's discount" do
-      @mock.expects(:post).once.returns(make_response(make_subscription))
-      sub = Stripe::Subscription.create(:plan => 'gold', :customer => 'c_test_customer', coupon: 'forever')
-
-      url = "#{Stripe.api_base}/v1/subscriptions/#{sub.id}/discount"
-      @mock.expects(:delete).once.with(url, nil, nil).returns(make_response(make_delete_discount_response))
-      sub.delete_discount
-      assert_equal nil, sub.discount
+    context "#delete_discount" do
+      should "be able to delete a subscriptions's discount" do
+        subscription = Stripe::Subscription.retrieve(FIXTURE[:id])
+        subscription = subscription.delete_discount
+        assert subscription.kind_of?(Stripe::Subscription)
+      end
     end
   end
 end

data/test/stripe/three_d_secure_test.rb

@@ -2,21 +2,22 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class ThreeDSecureTest < Test::Unit::TestCase
-    should "retrieve an existing 3D Secure object" do
-      @mock.expects(:get).once.returns(make_response(make_three_d_secure))
-      tds = Stripe::ThreeDSecure.retrieve("tdsrc_test")
-      assert_equal "tdsrc_test", tds.id
+    FIXTURE = API_FIXTURES.fetch(:three_d_secure)
+
+    should "be retrievable" do
+      secure = Stripe::ThreeDSecure.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/3d_secure/#{FIXTURE[:id]}"
+      assert secure.kind_of?(Stripe::ThreeDSecure)
     end
 
-    should "create should return a new 3D Secure object" do
-      @mock.expects(:post).once.returns(make_response(make_three_d_secure))
-      tds = Stripe::ThreeDSecure.create(
-        :card => "tok_test",
-        :amount => 1500,
-        :currency => "usd",
-        :return_url => "https://example.org/3d-secure-result"
+    should "be creatable" do
+      _ = Stripe::ThreeDSecure.create(
+        card: API_FIXTURES.fetch(:token)[:id],
+        amount: 1500,
+        currency: "usd",
+        return_url: "https://example.org/3d-secure-result"
       )
-      assert_equal "tdsrc_test", tds.id
+      assert_requested :post, "#{Stripe.api_base}/v1/3d_secure"
     end
   end
 end

data/test/stripe/transfer_test.rb

@@ -2,32 +2,49 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Stripe
   class TransferTest < Test::Unit::TestCase
-    should "retrieve should retrieve transfer" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
-      transfer = Stripe::Transfer.retrieve('tr_test_transfer')
-      assert_equal 'tr_test_transfer', transfer.id
+    FIXTURE = API_FIXTURES.fetch(:transfer)
+
+    should "be listable" do
+      transfers = Stripe::Transfer.list
+      assert_requested :get, "#{Stripe.api_base}/v1/transfers"
+      assert transfers.data.kind_of?(Array)
+      assert transfers.data[0].kind_of?(Stripe::Transfer)
+    end
+
+    should "be retrievable" do
+      transfer = Stripe::Transfer.retrieve(FIXTURE[:id])
+      assert_requested :get, "#{Stripe.api_base}/v1/transfers/#{FIXTURE[:id]}"
+      assert transfer.kind_of?(Stripe::Transfer)
     end
 
-    should "create should create a transfer" do
-      @mock.expects(:post).once.returns(make_response(make_transfer))
-      transfer = Stripe::Transfer.create
-      assert_equal "tr_test_transfer", transfer.id
+    should "be creatable" do
+      transfer = Stripe::Transfer.create(
+        amount: 100,
+        currency: "USD"
+      )
+      assert_requested :post, "#{Stripe.api_base}/v1/transfers"
+      assert transfer.kind_of?(Stripe::Transfer)
     end
 
-    should "create should update a transfer" do
-      @mock.expects(:post).once.
-        with("#{Stripe.api_base}/v1/transfers/test_transfer", nil, "metadata[foo]=bar").
-        returns(make_response(make_transfer(metadata: {foo: 'bar'})))
-      transfer = Stripe::Transfer.update("test_transfer", metadata: {foo: 'bar'})
-      assert_equal "bar", transfer.metadata['foo']
+    should "be saveable" do
+      transfer = Stripe::Transfer.retrieve(FIXTURE[:id])
+      transfer.metadata['key'] = 'value'
+      transfer.save
+      assert_requested :post, "#{Stripe.api_base}/v1/transfers/#{FIXTURE[:id]}"
     end
 
-    should "cancel should cancel a transfer" do
-      @mock.expects(:get).once.returns(make_response(make_transfer))
-      transfer = Stripe::Transfer.retrieve('tr_test_transfer')
+    should "be updateable" do
+      transfer = Stripe::Transfer.update(FIXTURE[:id], metadata: {foo: 'bar'})
+      assert_requested :post, "#{Stripe.api_base}/v1/transfers/#{FIXTURE[:id]}"
+      assert transfer.kind_of?(Stripe::Transfer)
+    end
 
-      @mock.expects(:post).once.with('https://api.stripe.com/v1/transfers/tr_test_transfer/cancel', nil, '').returns(make_response(make_canceled_transfer))
-      transfer.cancel
+    context "#cancel" do
+      should "cancel a transfer" do
+        transfer = Stripe::Transfer.retrieve(FIXTURE[:id])
+        transfer = transfer.cancel
+        assert transfer.kind_of?(Stripe::Transfer)
+      end
     end
   end
 end