paid 0.0.1

data/test/paid/api_resource_test.rb

@@ -0,0 +1,361 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class ApiResourceTest < Test::Unit::TestCase
+    should "creating a new APIResource should not fetch over the network" do
+      @mock.expects(:get).never
+      Paid::Customer.new("someid")
+    end
+
+    should "creating a new APIResource from a hash should not fetch over the network" do
+      @mock.expects(:get).never
+      Paid::Customer.construct_from({
+        :id => "somecustomer",
+        :object => "customer",
+        :email => 'someone@example.com',
+        :name => 'Some Business',
+        :account_id => 'acct_1234'
+      })
+    end
+
+    should "setting an attribute should not cause a network request" do
+      @mock.expects(:get).never
+      @mock.expects(:post).never
+      c = Paid::Customer.new("test_customer");
+      c.name = 'Another Name'
+    end
+
+    should "accessing id should not issue a fetch" do
+      @mock.expects(:get).never
+      c = Paid::Customer.new("test_customer")
+      c.id
+    end
+
+    should "not specifying api credentials should raise an exception" do
+      Paid.api_key = nil
+      assert_raises Paid::AuthenticationError do
+        Paid::Customer.new("test_customer").refresh
+      end
+    end
+
+    should "specifying api credentials containing whitespace should raise an exception" do
+      Paid.api_key = "key "
+      assert_raises Paid::AuthenticationError do
+        Paid::Customer.new("test_customer").refresh
+      end
+    end
+
+    should "specifying invalid api credentials should raise an exception" do
+      Paid.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      assert_raises Paid::AuthenticationError do
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Paid::Customer.retrieve("failing_customer")
+      end
+    end
+
+    should "AuthenticationErrors should have an http status, http body, and JSON body" do
+      Paid.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      begin
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Paid::Customer.retrieve("failing_customer")
+      rescue Paid::AuthenticationError => e
+        assert_equal(401, e.http_status)
+        assert_equal(true, !!e.http_body)
+        assert_equal(true, !!e.json_body[:error][:message])
+        assert_equal(test_invalid_api_key_error[:error][:message], e.json_body[:error][:message])
+      end
+    end
+
+    should "send paid account as header when set" do
+      paid_account = "acct_0000"
+      Paid.expects(:execute_request).with do |opts|
+        opts[:headers][:paid_account] == paid_account
+      end.returns(test_response(test_transaction))
+
+      Paid::Transaction.create({:amount => 100},
+                            {:paid_account => paid_account, :api_key => 'sk_test_local'})
+    end
+
+    should "not send paid account as header when not set" do
+      Paid.expects(:execute_request).with do |opts|
+        opts[:headers][:paid_account].nil?
+      end.returns(test_response(test_transaction))
+
+      Paid::Transaction.create(
+        {
+          :amount => 200,
+          :description => 'This is a description.',
+          :customer => 'somecustomer'
+
+        },
+        'sk_test_local'
+      )
+    end
+
+    context "when specifying per-object credentials" do
+      context "with no global API key set" do
+        should "use the per-object credential when creating" do
+          Paid.expects(:execute_request).with do |opts|
+            opts[:headers][:authorization] == 'Bearer sk_test_local'
+          end.returns(test_response(test_transaction))
+
+          Paid::Transaction.create(
+            {
+              :amount => 200,
+              :description => 'This is a description.',
+              :customer => 'somecustomer'
+            },
+            'sk_test_local'
+          )
+        end
+      end
+
+      context "with a global API key set" do
+        setup do
+          Paid.api_key = "global"
+        end
+
+        teardown do
+          Paid.api_key = nil
+        end
+
+        should "use the per-object credential when creating" do
+          Paid.expects(:execute_request).with do |opts|
+            opts[:headers][:authorization] == 'Bearer local'
+          end.returns(test_response(test_transaction))
+
+          Paid::Transaction.create(
+            {
+              :amount => 200,
+              :description => 'This is a description.',
+              :customer => 'somecustomer'
+            },
+            'local'
+          )
+        end
+
+        should "use the per-object credential when retrieving and making other calls" do
+          Paid.expects(:execute_request).with do |opts|
+            opts[:url] == "#{Paid.api_base}/v0/transactions/tr_test_transaction" &&
+              opts[:headers][:authorization] == 'Bearer local'
+          end.returns(test_response(test_transaction))
+
+          ch = Paid::Transaction.retrieve('tr_test_transaction', 'local')
+        end
+      end
+    end
+
+    context "with valid credentials" do
+      should "send along the idempotency-key header" do
+        Paid.expects(:execute_request).with do |opts|
+          opts[:headers][:idempotency_key] == 'bar'
+        end.returns(test_response(test_transaction))
+
+        Paid::Transaction.create(
+          {
+            :amount => 200,
+            :description => 'This is a description.',
+            :customer => 'somecustomer'
+          }, 
+          {
+            :idempotency_key => 'bar',
+            :api_key => 'local',
+          }
+        )
+      end
+
+      should "urlencode values in GET params" do
+        response = test_response(test_transaction_array)
+        @mock.expects(:get).with("#{Paid.api_base}/v0/transactions?customer=test%20customer", nil, nil).returns(response)
+        transactions = Paid::Transaction.all(:customer => 'test customer').data
+        assert transactions.kind_of? Array
+      end
+
+      should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
+        response = test_response(test_missing_id_error, 400)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          Paid::Customer.retrieve("foo")
+        rescue Paid::InvalidRequestError => e
+          assert_equal(400, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.kind_of?(Hash))
+        end
+      end
+
+      should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
+        response = test_response(test_missing_id_error, 401)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          Paid::Customer.retrieve("foo")
+        rescue Paid::AuthenticationError => e
+          assert_equal(401, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.kind_of?(Hash))
+        end
+      end
+
+      should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
+        response = test_response(test_missing_id_error, 404)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          Paid::Customer.retrieve("foo")
+        rescue Paid::InvalidRequestError => e
+          assert_equal(404, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.kind_of?(Hash))
+        end
+      end
+
+      should "setting a nil value for a param should exclude that param from the request" do
+        @mock.expects(:get).with do |url, api_key, params|
+          uri = URI(url)
+          query = CGI.parse(uri.query)
+          (url =~ %r{^#{Paid.api_base}/v0/transactions?} &&
+           query.keys.sort == ['offset', 'sad'])
+        end.returns(test_response({ :count => 1, :data => [test_transaction] }))
+        Paid::Transaction.all(:count => nil, :offset => 5, :sad => false)
+
+        @mock.expects(:post).with do |url, api_key, params|
+          url == "#{Paid.api_base}/v0/transactions" &&
+            api_key.nil? &&
+            CGI.parse(params) == { 'amount' => ['100'] }
+        end.returns(test_response({ :count => 1, :data => [test_transaction] }))
+        Paid::Transaction.create(:amount => 100)
+      end
+
+      should "requesting with a unicode ID should result in a request" do
+        response = test_response(test_missing_id_error, 404)
+        @mock.expects(:get).once.with("#{Paid.api_base}/v0/customers/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
+        c = Paid::Customer.new("☃")
+        assert_raises(Paid::InvalidRequestError) { c.refresh }
+      end
+
+      should "requesting with no ID should result in an InvalidRequestError with no request" do
+        c = Paid::Customer.new
+        assert_raises(Paid::InvalidRequestError) { c.refresh }
+      end
+
+      should "making a GET request with parameters should have a query string and no body" do
+        params = { :limit => 1 }
+        @mock.expects(:get).once.with("#{Paid.api_base}/v0/transactions?limit=1", nil, nil).returns(test_response([test_transaction]))
+        Paid::Transaction.all(params)
+      end
+
+      should "making a POST request with parameters should have a body and no query string" do
+        params = { :amount => 100, :alias => 'test_alias' }
+        @mock.expects(:post).once.with do |url, get, post|
+          get.nil? && CGI.parse(post) == {'amount' => ['100'], 'alias' => ['test_alias']}
+        end.returns(test_response(test_transaction))
+        Paid::Transaction.create(params)
+      end
+
+      should "loading an object should issue a GET request" do
+        @mock.expects(:get).once.returns(test_response(test_customer))
+        c = Paid::Customer.new("test_customer")
+        c.refresh
+      end
+
+      should "using array accessors should be the same as the method interface" do
+        @mock.expects(:get).once.returns(test_response(test_customer))
+        c = Paid::Customer.new("test_customer")
+        c.refresh
+        assert_equal c.created, c[:created]
+        assert_equal c.created, c['created']
+        c['created'] = 12345
+        assert_equal c.created, 12345
+      end
+
+      should "accessing a property other than id or parent on an unfetched object should fetch it" do
+        @mock.expects(:get).once.returns(test_response(test_customer))
+        c = Paid::Customer.new("test_customer")
+        c.transactions
+      end
+
+      should "updating an object should issue a POST request with only the changed properties" do
+        @mock.expects(:post).with do |url, api_key, params|
+          url == "#{Paid.api_base}/v0/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
+        end.once.returns(test_response(test_customer))
+        c = Paid::Customer.construct_from(test_customer)
+        c.description = "another_mn"
+        c.save
+      end
+
+      should "updating should merge in returned properties" do
+        @mock.expects(:post).once.returns(test_response(test_customer))
+        c = Paid::Customer.new("c_test_customer")
+        c.description = "another_mn"
+        c.save
+        # assert_equal false, c.livemode
+      end
+
+      should "deleting should send no props and result in an object that has no props other deleted" do
+        @mock.expects(:get).never
+        @mock.expects(:post).never
+        @mock.expects(:delete).with("#{Paid.api_base}/v0/customers/c_test_customer", nil, nil).once.returns(test_response({ "id" => "test_customer", "deleted" => true }))
+
+        c = Paid::Customer.construct_from(test_customer)
+        c.delete
+        assert_equal true, c.deleted
+
+        assert_raises NoMethodError do
+          c.livemode
+        end
+      end
+
+      should "loading an object with properties that have specific types should instantiate those classes" do
+        @mock.expects(:get).once.returns(test_response(test_transaction))
+        t = Paid::Transaction.retrieve("test_transaction")
+        assert t.kind_of?(Paid::PaidObject) && t.object == 'transaction'
+      end
+
+      should "loading all of an APIResource should return an array of recursively instantiated objects" do
+        @mock.expects(:get).once.returns(test_response(test_transaction_array))
+        t = Paid::Transaction.all.data
+        assert t.kind_of? Array
+        assert t[0].kind_of? Paid::Transaction
+        assert t[0].kind_of?(Paid::PaidObject) && t[0].object == 'transaction'
+      end
+
+      context "error checking" do
+
+        should "404s should raise an InvalidRequestError" do
+          response = test_response(test_missing_id_error, 404)
+          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+
+          rescued = false
+          begin
+            Paid::Customer.new("test_customer").refresh
+            assert false #shouldn't get here either
+          rescue Paid::InvalidRequestError => e # we don't use assert_raises because we want to examine e
+            rescued = true
+            assert e.kind_of? Paid::InvalidRequestError
+            assert_equal "id", e.param
+            assert_equal "Missing id", e.message
+          end
+
+          assert_equal true, rescued
+        end
+
+        should "5XXs should raise an APIError" do
+          response = test_response(test_api_error, 500)
+          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
+
+          rescued = false
+          begin
+            Paid::Customer.new("test_customer").refresh
+            assert false #shouldn't get here either
+          rescue Paid::APIError => e # we don't use assert_raises because we want to examine e
+            rescued = true
+            assert e.kind_of? Paid::APIError
+          end
+
+          assert_equal true, rescued
+        end
+      end
+    end
+  end
+end

data/test/paid/certificate_blacklist_test.rb

@@ -0,0 +1,18 @@
+# require File.expand_path('../../test_helper', __FILE__)
+
+# module Paid
+
+#   class CertificateBlacklistTest < Test::Unit::TestCase
+#     should "not trust revoked certificates" do
+#       assert_raises(Paid::APIConnectionError) {
+#         Paid::CertificateBlacklist.check_ssl_cert("https://revoked.paidapi.com:444",
+#                                                     Paid::DEFAULT_CA_BUNDLE_PATH)
+#       }
+#     end
+
+#     should "trust api.paidapi.com" do
+#       assert_true Paid::CertificateBlacklist.check_ssl_cert("https://api.paidapi.com",
+#                                                               Paid::DEFAULT_CA_BUNDLE_PATH)
+#     end
+#   end
+# end

data/test/paid/customer_test.rb

@@ -0,0 +1,35 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class CustomerTest < Test::Unit::TestCase
+    should "customers should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_customer_array))
+      c = Paid::Customer.all.data
+      assert c.kind_of? Array
+      assert c[0].kind_of? Paid::Customer
+    end
+
+    should "customers should be deletable" do
+      @mock.expects(:delete).once.returns(test_response(test_customer({:deleted => true})))
+      c = Paid::Customer.new("test_customer")
+      c.delete
+      assert c.deleted
+    end
+
+    should "customers should be updateable" do
+      @mock.expects(:get).once.returns(test_response(test_customer({:mnemonic => "foo"})))
+      @mock.expects(:post).once.returns(test_response(test_customer({:mnemonic => "bar"})))
+      c = Paid::Customer.new("test_customer").refresh
+      assert_equal "foo", c.mnemonic
+      c.mnemonic = "bar"
+      c.save
+      assert_equal "bar", c.mnemonic
+    end
+
+    should "create should return a new customer" do
+      @mock.expects(:post).once.returns(test_response(test_customer))
+      c = Paid::Customer.create
+      assert_equal "c_test_customer", c.id
+    end
+  end
+end

data/test/paid/invoice_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class InvoiceTest < Test::Unit::TestCase
+    should "retrieve should retrieve invoices" do
+      @mock.expects(:get).once.returns(test_response(test_invoice))
+      i = Paid::Invoice.retrieve('in_test_invoice')
+      assert_equal 'inv_test_invoice', i.id
+    end
+
+    should "create should create a new invoice" do
+      @mock.expects(:post).once.returns(test_response(test_invoice))
+      i = Paid::Invoice.create
+      assert_equal "inv_test_invoice", i.id
+    end
+
+    # should "pay should pay an invoice" do
+    #   @mock.expects(:get).once.returns(test_response(test_invoice))
+    #   i = Paid::Invoice.retrieve('in_test_invoice')
+
+    #   @mock.expects(:post).once.with('https://api.paidapi.com/v0/invoices/in_test_invoice/pay', nil, '').returns(test_response(test_paid_invoice))
+    #   i.pay
+    #   assert_equal nil, i.next_payment_attempt
+    # end
+  end
+end

data/test/paid/list_object_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class ListObjectTest < Test::Unit::TestCase
+    should "be able to retrieve full lists given a listobject" do
+      @mock.expects(:get).twice.returns(test_response(test_transaction_array))
+      c = Paid::Transaction.all
+      assert c.kind_of?(Paid::ListObject)
+      assert_equal('/v0/transactions', c.url)
+      all = c.all
+      assert all.kind_of?(Paid::ListObject)
+      assert_equal('/v0/transactions', all.url)
+      assert all.data.kind_of?(Array)
+    end
+  end
+end

data/test/paid/metadata_test.rb

@@ -0,0 +1,104 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class MetadataTest < Test::Unit::TestCase
+    setup do
+      @metadata_supported = {
+        :transaction => {
+          :new => Paid::Transaction.method(:new),
+          :test => method(:test_transaction),
+          :url => "/v0/transactions/#{test_transaction()[:id]}"
+        },
+        :customer => {
+          :new => Paid::Customer.method(:new),
+          :test => method(:test_customer),
+          :url => "/v0/customers/#{test_customer()[:id]}"
+        }
+      }
+
+      @base_url = 'https://api.paidapi.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 = Paid.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(test_response(initial_test_obj))
+
+        final_test_obj = test.call()
+        @mock.expects(:post).once.
+          returns(test_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/paid/paid_object_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class PaidObjectTest < Test::Unit::TestCase
+    should "implement #respond_to correctly" do
+      obj = Paid::PaidObject.construct_from({ :id => 1, :foo => 'bar' })
+      assert obj.respond_to?(:id)
+      assert obj.respond_to?(:foo)
+      assert !obj.respond_to?(:baz)
+    end
+
+    should "marshal a paid object correctly" do
+      obj = Paid::PaidObject.construct_from({ :id => 1, :name => 'Paid' }, 'apikey')
+      m = Marshal.load(Marshal.dump(obj))
+      assert_equal 1, m.id
+      assert_equal 'Paid', m.name
+      assert_equal 'apikey', m.api_key
+    end
+
+    should "recursively call to_hash on its values" do
+      nested = Paid::PaidObject.construct_from({ :id => 7, :foo => 'bar' })
+      obj = Paid::PaidObject.construct_from({ :id => 1, :nested => nested })
+      expected_hash = { :id => 1, :nested => { :id => 7, :foo => 'bar' } }
+      assert_equal expected_hash, obj.to_hash
+    end
+  end
+end

data/test/paid/transaction_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class TransactionTest < Test::Unit::TestCase
+    should "transactions should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_transaction_array))
+      c = Paid::Transaction.all
+      assert c.data.kind_of? Array
+      c.each do |transaction|
+        assert transaction.kind_of?(Paid::Transaction)
+      end
+    end
+
+    should "transactions should not be deletable" do
+      assert_raises NoMethodError do
+        @mock.expects(:get).once.returns(test_response(test_transaction))
+        c = Paid::Transaction.retrieve("test_transaction")
+        c.delete
+      end
+    end
+
+    should "transactions should be updateable" do
+      @mock.expects(:get).once.returns(test_response(test_transaction))
+      @mock.expects(:post).once.returns(test_response(test_transaction))
+      c = Paid::Transaction.new("test_transaction")
+      c.refresh
+      c.mnemonic = "New transaction description"
+      c.save
+    end
+
+    should "execute should return a new, fully executed transaction when passed correct parameters" do
+      @mock.expects(:post).with do |url, api_key, params|
+        url == "#{Paid.api_base}/v0/transactions" && api_key.nil? && CGI.parse(params) == {
+            'amount' => ['100'],
+            'description' => ['a description'],
+            'customer' => ['c_test_customer']
+        }
+      end.once.returns(test_response(test_transaction))
+
+      c = Paid::Transaction.create({
+        :amount => 100,
+        :description => 'a description',
+        :customer => 'c_test_customer'
+      })
+
+      assert !c.paid
+    end
+  end
+end