stripe 1.27.2 → 5.33.0

data/test/stripe/dispute_test.rb

@@ -1,45 +0,0 @@
-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)
-    end
-
-    should "disputes should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_dispute_array))
-      d = Stripe::Dispute.all
-      assert d.data.kind_of? Array
-      d.each do |dispute|
-        assert dispute.kind_of?(Stripe::Dispute)
-      end
-    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
-    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))
-
-      d = Stripe::Dispute.new('test_dispute')
-      d.refresh
-      d.evidence['customer_name'] = 'customer'
-      d.save
-    end
-  end
-end

data/test/stripe/file_upload_test.rb

@@ -1,28 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class FileUploadTest < Test::Unit::TestCase
-    should "create should return a new file" do
-      @mock.expects(:post).once.returns(make_response(make_file))
-      f = Stripe::FileUpload.create({
-        :purpose => "dispute_evidence",
-        :file => File.new(__FILE__),
-      })
-      assert_equal "fil_test_file", f.id
-    end
-
-    should "files should be retrievable" do
-      @mock.expects(:get).once.returns(make_response(make_file))
-      c = Stripe::FileUpload.new("fil_test_file")
-      c.refresh
-      assert_equal 1403047735, c.created
-    end
-
-    should "files should be listable" do
-      @mock.expects(:get).once.returns(make_response(make_file_array))
-      c = Stripe::FileUpload.all.data
-      assert c.kind_of? Array
-      assert c[0].kind_of? Stripe::FileUpload
-    end
-  end
-end

data/test/stripe/invoice_test.rb

@@ -1,40 +0,0 @@
-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
-
-    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
-    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
-    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
-    end
-  end
-end

data/test/stripe/list_object_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class ListObjectTest < Test::Unit::TestCase
-    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.url)
-      all = c.all
-      assert all.kind_of?(Stripe::ListObject)
-      assert_equal('/v1/charges', all.url)
-      assert all.data.kind_of?(Array)
-    end
-  end
-end

data/test/stripe/metadata_test.rb

@@ -1,129 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class MetadataTest < Test::Unit::TestCase
-    setup do
-      @metadata_supported = {
-        :charge => {
-          :new => Stripe::Charge.method(:new),
-          :test => method(:make_charge),
-          :url => "/v1/charges/#{make_charge()[:id]}"
-        },
-        :customer => {
-          :new => Stripe::Customer.method(:new),
-          :test => method(:make_customer),
-          :url => "/v1/customers/#{make_customer()[:id]}"
-        },
-        :recipient => {
-          :new => Stripe::Recipient.method(:new),
-          :test => method(:make_recipient),
-          :url => "/v1/recipients/#{make_recipient()[:id]}"
-        },
-        :transfer => {
-          :new => Stripe::Transfer.method(:new),
-          :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'
-    end
-
-    should "not touch metadata" do
-      update_actions = lambda {|obj| obj.description = 'test'}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                    'description=test',
-                    update_actions)
-    end
-
-
-    should "update metadata as a whole" do
-      update_actions = lambda {|obj| obj.metadata = {'uuid' => '6735'}}
-      check_metadata({:metadata => {}},
-                    'metadata[uuid]=6735',
-                    update_actions)
-
-      if is_greater_than_ruby_1_9?
-        check_metadata({:metadata => {:initial => 'true'}},
-                      'metadata[uuid]=6735&metadata[initial]=',
-                      update_actions)
-      end
-    end
-
-    should "update metadata keys individually" do
-      update_actions = lambda {|obj| obj.metadata['txn_id'] = '134a13'}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                     'metadata[txn_id]=134a13',
-                     update_actions)
-    end
-
-    should "clear metadata as a whole" do
-      update_actions = lambda {|obj| obj.metadata = nil}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                     'metadata=',
-                     update_actions)
-    end
-
-    should "clear metadata keys individually" do
-      update_actions = lambda {|obj| obj.metadata['initial'] = nil}
-      check_metadata({:metadata => {'initial' => 'true'}},
-                     'metadata[initial]=',
-                     update_actions)
-    end
-
-    should "handle combinations of whole and partial metadata updates" do
-      if is_greater_than_ruby_1_9?
-        update_actions = lambda do |obj|
-          obj.metadata = {'type' => 'summer'}
-          obj.metadata['uuid'] = '6735'
-        end
-        params = {:metadata => {'type' => 'summer', 'uuid' => '6735'}}
-        curl_args = Stripe.uri_encode(params)
-        check_metadata({:metadata => {'type' => 'christmas'}},
-                       curl_args,
-                       update_actions)
-      end
-    end
-
-    def check_metadata (initial_params, curl_args, metadata_update)
-      @metadata_supported.each do |name, methods|
-        neu = methods[:new]
-        test = methods[:test]
-        url = @base_url + methods[:url]
-
-        initial_test_obj = test.call(initial_params)
-        @mock.expects(:get).once.returns(make_response(initial_test_obj))
-
-        final_test_obj = test.call()
-        @mock.expects(:post).once.
-          returns(make_response(final_test_obj)).
-          with(url, nil, curl_args)
-
-        obj = neu.call("test")
-        obj.refresh()
-        metadata_update.call(obj)
-        obj.save
-      end
-    end
-
-    def is_greater_than_ruby_1_9?
-      version = RUBY_VERSION.dup  # clone preserves frozen state
-      Gem::Version.new(version) >= Gem::Version.new('1.9')
-    end
-  end
-end

data/test/stripe/order_test.rb

@@ -1,52 +0,0 @@
-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.all
-      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

@@ -1,41 +0,0 @@
-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.all
-      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

@@ -1,57 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-module Stripe
-  class RecipientCardTest < Test::Unit::TestCase
-    RECIPIENT_CARD_URL = '/v1/recipients/test_recipient/cards/test_card'
-
-    def 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(make_response(make_recipient_card_array(recipient.id)))
-      cards = c.cards.all.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(make_response(make_card(
-        :id => 'test_card',
-        :recipient => 'test_recipient'
-      )))
-      card = c.cards.retrieve('card')
-      assert_equal RECIPIENT_CARD_URL, card.url
-    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
-    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"
-      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
-    end
-  end
-end

data/test/stripe/refund_test.rb

@@ -1,55 +0,0 @@
-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))
-
-      refunds = Stripe::Refund.all
-
-      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
-    end
-
-    should "refunds should be updateable" 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']
-
-      refund.metadata['key'] = 'value'
-      refund.save
-
-      assert_equal 'value', refund.metadata['key']
-    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
-    end
-  end
-end