invoiced 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9ab812bcc11b135cd567621a8388872e4794d41
-  data.tar.gz: ea415b98ad24754e621c1f81a08d15eb6de0c358
+  metadata.gz: d309d5779157c8855a9715ee6fcab533e115c882
+  data.tar.gz: a68bb49eb9f049e6c8fccdcc45e9c4b1f606e345
 SHA512:
-  metadata.gz: 921af214c15490031e38ce6bc4bf505b35f156c2e52fe6baa3f480b8855d010aea4f023e50f4fde4f3871d9b60444c310304544f35f29cda01f45aaa1e184adc
-  data.tar.gz: cba482dc00f4be0eae7ba4edb8b8a2d122fcf6cef30e1c63221154104fb1e05101f77073b47d4713d0117e1289dd7416671fc37ab4b7009f2ddbbea0953e6a2c
+  metadata.gz: cbb3a5fd43352b3926ab8250b55d85330a702d2a28cd9063c8dfe79e8db12f3ee08cd57752bb01c9e05e1c05371cda8aedfb6afb97144148cce7c3c39e6f0954
+  data.tar.gz: 79f215a059b3918b226a150ef3c88cd4b0c278b93842d1116aee67960f1f64e282976e4292be0ae4af2b556f768170797d69b6b20c51124d1c1f03bc7d8bca75

data/.gitignore

@@ -1,3 +1,4 @@
 Gemfile.lock
 example.rb
-/invoiced-*.gem
+/invoiced-*.gem
+/coverage

data/Gemfile

@@ -3,4 +3,7 @@ gemspec
 
 gem 'json', '~> 1.8.3'
 gem 'rest-client', '~> 1.8.0'
-gem 'activesupport', '~> 4.2.3'
+gem 'activesupport', '~> 4.2.3'
+gem 'coveralls', :require => false, :group => :test
+gem 'simplecov', :require => false, :group => :test
+gem 'simplecov-console', :require => false, :group => :test

data/README.md

@@ -3,6 +3,9 @@ invoiced-ruby
 
 This repository contains the Ruby client library for the [Invoiced](https://invoiced.com) API.
 
+[![Build Status](https://travis-ci.org/Invoiced/invoiced-ruby.svg?branch=master)](https://travis-ci.org/Invoiced/invoiced-ruby)
+[![Coverage Status](https://coveralls.io/repos/Invoiced/invoiced-ruby/badge.svg?branch=master&service=github)](https://coveralls.io/github/Invoiced/invoiced-ruby?branch=master)
+
 ## Installing
 
 The Invoiced gem can be installed liked this:

data/lib/invoiced/error/api_connection_error.rb

@@ -0,0 +1,5 @@
+module Invoiced
+	class ApiConnectionError < ErrorBase
+
+	end
+end

data/lib/invoiced/invoice.rb

@@ -17,7 +17,7 @@ module Invoiced
 			response = @client.request(:post, "#{@endpoint}/pay")
 
 			# update the local values with the response
-			@values = response[:body].dup.merge({:id => self.id})
+			refresh_from(response[:body].dup.merge({:id => self.id}))
 
 			return response[:code] == 200
 		end

data/lib/invoiced/object.rb

@@ -16,8 +16,8 @@ module Invoiced
 
 			if !id.nil?
 				@endpoint += "/#{id}"
-				@values = values.dup.merge({:id => id})
 				@unsaved = Set.new
+				refresh_from(values.dup.merge({:id => id}))
 			end
 		end
 
@@ -43,6 +43,26 @@ module Invoiced
 			"#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
 		end
 
+		def refresh_from(values)
+			removed = Set.new(@values.keys - values.keys)
+			added = Set.new(values.keys - @values.keys)
+
+			instance_eval do
+				remove_accessors(removed)
+				add_accessors(added)
+			end
+			removed.each do |k|
+				@values.delete(k)
+				@unsaved.delete(k)
+			end
+			values.each do |k, v|
+				@values[k] = v
+				@unsaved.delete(k)
+			end
+
+			return self
+		end
+
 	    def [](k)
 	    	@values[k.to_sym]
 	    end
@@ -63,10 +83,6 @@ module Invoiced
 	    	JSON.generate(@values)
 	    end
 
-	    def as_json(*a)
-	    	@values.as_json(*a)
-	    end
-
 	    def to_hash
 	    	@values.inject({}) do |acc, (key, value)|
 	        	acc[key] = value.respond_to?(:to_hash) ? value.to_hash : value

data/lib/invoiced/operations/delete.rb

@@ -4,7 +4,9 @@ module Invoiced
 			def delete
     			response = @client.request(:delete, @endpoint)
 
-    			@values = {:id => @id}
+    			if response[:code] == 204
+                    refresh_from({:id => @id})
+    			end
 
     			return response[:code] == 204
     		end

data/lib/invoiced/operations/update.rb

@@ -15,11 +15,12 @@ module Invoiced
     				response = @client.request(:patch, @endpoint, update)
 
     				# update the local values with the response
-    				@values = response[:body].dup.merge({:id => self.id})
-    				@unsaved = Set.new
+    				refresh_from(response[:body].dup.merge({:id => self.id}))
 
     				return response[:code] == 200
 		        end
+
+		        false
     		end
 		end
 	end

data/lib/invoiced/util.rb

@@ -23,13 +23,7 @@ module Invoiced
 			private
 
 			def url_encode(params)
-				if params.is_a?(Hash)
-					params.map {
-						|k,v| "#{k}=#{uri_encode(v)}"
-					}.join('&')
-				else
-					URI.escape(params.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-				end
+				URI.escape(params.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
 			end
 
 			def flatten_params(params, parent_key=nil)

data/lib/invoiced/version.rb

@@ -1,3 +1,3 @@
 module Invoiced
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end

data/lib/invoiced.rb

@@ -6,6 +6,7 @@ require 'active_support/inflector'
 require 'invoiced/version'
 require 'invoiced/util'
 require 'invoiced/error/error_base'
+require 'invoiced/error/api_connection_error'
 require 'invoiced/error/api_error'
 require 'invoiced/error/authentication_error'
 require 'invoiced/error/invalid_request'
@@ -28,29 +29,15 @@ module Invoiced
 		ApiBase = 'https://api.invoiced.com'
 
 		attr_reader :api_key
+		attr_reader :Customer, :Invoice, :Transaction, :Plan, :Subscription
 
 	    def initialize(api_key)
 	      @api_key = api_key
-	    end
-
-	    def Customer
-	    	Invoiced::Customer.new(self)
-	    end
-
-	    def Invoice
-	    	Invoiced::Invoice.new(self)
-	    end
-
-	    def Transaction
-	    	Invoiced::Transaction.new(self)
-	    end
-
-	    def Plan
-	    	Invoiced::Plan.new(self)
-	    end
-
-	    def Subscription
-	    	Invoiced::Subscription.new(self)
+	      @Customer = Invoiced::Customer.new(self)
+	      @Invoice = Invoiced::Invoice.new(self)
+	      @Transaction = Invoiced::Transaction.new(self)
+	      @Plan = Invoiced::Plan.new(self)
+	      @Subscription = Invoiced::Subscription.new(self)
 	    end
 
 	    def request(method, endpoint, params={})
@@ -69,17 +56,14 @@ module Invoiced
 
 			begin
 		    	response = RestClient::Request.execute(
-		    		method: method,
-		    		url: url,
-		    		headers: {
+		    		:method => method,
+		    		:url => url,
+		    		:headers => {
 		    			:authorization => Util.auth_header(@api_key),
 		    			:content_type => "application/json",
-		    			:user_agent => "Invoiced Ruby/#{Invoiced::VERSION}",
-		    			# pass in query parameters here due
-		    			# to an eccentricity in the rest-client gem
-		    			# :params => params.merge({:envelope => '0'})
+		    			:user_agent => "Invoiced Ruby/#{Invoiced::VERSION}"
 		    		},
-		    		payload: payload
+		    		:payload => payload
 		    	)
 		    rescue RestClient::Exception => e
 		    	if e.response
@@ -126,23 +110,23 @@ module Invoiced
 	    end
 
 	    def rescue_rest_client_error(error)
-	    	raise ApiError.new("There was an error connecting to Invoiced.")
+	    	raise ApiConnectionError.new("There was an error connecting to Invoiced.")
 	    end
 
 	    def authentication_error(error, response)
-	    	raise AuthenticationError.new(error["message"], response.code, error)
+	    	AuthenticationError.new(error["message"], response.code, error)
 	    end
 
 	    def invalid_request_error(error, response)
-	    	raise InvalidRequestError.new(error["message"], response.code, error)
+	    	InvalidRequestError.new(error["message"], response.code, error)
 	    end
 
 	    def api_error(error, response)
-	    	raise ApiError.new(error["message"], response.code, error)
+	    	ApiError.new(error["message"], response.code, error)
 	    end
 
 	    def general_api_error(code, body)
-	    	raise ApiError.new("API Error #{code} - #{body}", code)
+	    	ApiError.new("API Error #{code} - #{body}", code)
 	    end
 	end
 end

data/test/invoiced/customer_test.rb

@@ -3,40 +3,138 @@ require File.expand_path('../../test_helper', __FILE__)
 module Invoiced
   class CustomerTest < Test::Unit::TestCase
     should "create a customer" do
-      customer = @client.Customer.create({:name => "test"})
-    end
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('{"id":123,"name":"Pied Piper"}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
 
-  	should "list all customers" do
-      @client.Customer.list
-  	end
+      customer = @client.Customer.create({:name => "Pied Piper"})
+
+      assert_instance_of(Invoiced::Customer, customer)
+      assert_equal(123, customer.id)
+      assert_equal('Pied Piper', customer.name)
+    end
 
     should "retrieve a customer" do
-      customer = @client.Customer.retrieve(1234)
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"id":"123","name":"Pied Piper"}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      customer = @client.Customer.retrieve(123)
+
+      assert_instance_of(Invoiced::Customer, customer)
+      assert_equal(123, customer.id)
+      assert_equal('Pied Piper', customer.name)
+    end
+
+    should "not update a customer when no params" do
+      customer = Customer.new(@client, 123)
+      assert_false(customer.save)
     end
 
     should "update a customer" do
-      customer = Customer.new(@client, 1234)
-      customer.name = 'Update'
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"id":123,"name":"Pied Piper","notes":"Terrible customer"}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      customer = Customer.new(@client, 123)
+      customer.notes = 'Terrible customer'
       assert_true(customer.save)
+
+      assert_equal("Terrible customer", customer.notes)
+    end
+
+    should "list all customers" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('[{"id":123,"name":"Pied Piper"}]')
+      mockResponse.stubs(:headers).returns(:x_total_count => 15, :link => '<https://api.invoiced.com/customers?per_page=25&page=1>; rel="self", <https://api.invoiced.com/customers?per_page=25&page=1>; rel="first", <https://api.invoiced.com/customers?per_page=25&page=1>; rel="last"')
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      customers, metadata = @client.Customer.list
+
+      assert_instance_of(Array, customers)
+      assert_equal(1, customers.length)
+      assert_equal(123, customers[0].id)
+
+      assert_instance_of(Invoiced::List, metadata)
+      assert_equal(15, metadata.total_count)
+    end
+
+    should "delete a customer" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(204)
+      mockResponse.stubs(:body).returns('')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      customer = Customer.new(@client, 123)
+      assert_true(customer.delete)
     end
 
     should "send an account statement" do
-      customer = Customer.new(@client, 1234)
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('[{"id":4567,"email":"test@example.com"}]')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      customer = Customer.new(@client, 123)
       emails = customer.send_statement
+
+      assert_instance_of(Array, emails)
+      assert_equal(1, emails.length)
+      assert_instance_of(Invoiced::Email, emails[0])
+      assert_equal(4567, emails[0].id)
     end
 
     should "retrieve a customer's balance" do
-      customer = Customer.new(@client, 1234)
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"total_outstanding":1000,"available_credits":0,"past_due":true}')
+      mockResponse.stubs(:headers).returns(:x_total_count => 10, :link => '<https://api.invoiced.com/customers/123/subscriptions?per_page=25&page=1>; rel="self", <https://api.invoiced.com/customers/123/subscriptions?per_page=25&page=1>; rel="first", <https://api.invoiced.com/customers/123/subscriptions?per_page=25&page=1>; rel="last"')
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      customer = Customer.new(@client, 123)
       balance = customer.balance
+
+      expected = {
+        :past_due => true,
+        :available_credits => 0,
+        :total_outstanding => 1000
+      }
+
+      assert_equal(expected, balance)
     end
 
     should "list all of the customer's subscriptions" do
-      @client.Customer.subscriptions
-    end
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('[{"id":123,"plan":456}]')
+      mockResponse.stubs(:headers).returns(:x_total_count => 10, :link => '<https://api.invoiced.com/customers/123/subscriptions?per_page=25&page=1>; rel="self", <https://api.invoiced.com/customers/123/subscriptions?per_page=25&page=1>; rel="first", <https://api.invoiced.com/customers/123/subscriptions?per_page=25&page=1>; rel="last"')
 
-    should "delete a customer" do
-      customer = Customer.new(@client, 1234)
-      assert_true(customer.delete)
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      subscriptions, metadata = @client.Customer.subscriptions
+
+      assert_instance_of(Array, subscriptions)
+      assert_equal(1, subscriptions.length)
+      assert_equal(123, subscriptions[0].id)
+
+      assert_instance_of(Invoiced::List, metadata)
+      assert_equal(10, metadata.total_count)
     end
   end
 end

data/test/invoiced/error_test.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Invoiced
+  class UtilTest < Test::Unit::TestCase
+  	should "create an api error" do
+  		error = ApiError.new("ERROR!", 500)
+  		assert_equal("(500): ERROR!", error.to_s)
+  	end
+  end
+end

data/test/invoiced/invoice_test.rb

@@ -3,36 +3,114 @@ require File.expand_path('../../test_helper', __FILE__)
 module Invoiced
   class InvoiceTest < Test::Unit::TestCase
     should "create an invoice" do
-      invoice = @client.Invoice.create({:customer => 123})
-    end
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('{"id":123,"number":"INV-0001"}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
 
-  	should "list all invoices" do
-      @client.Invoice.list
-  	end
+      invoice = @client.Invoice.create({:number => "INV-0001"})
+
+      assert_instance_of(Invoiced::Invoice, invoice)
+      assert_equal(123, invoice.id)
+      assert_equal('INV-0001', invoice.number)
+    end
 
     should "retrieve an invoice" do
-      invoice = @client.Invoice.retrieve(1234)
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"id":123,"number":"INV-0001"}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      invoice = @client.Invoice.retrieve(123)
+
+      assert_instance_of(Invoiced::Invoice, invoice)
+      assert_equal(123, invoice.id)
+      assert_equal('INV-0001', invoice.number)
+    end
+
+    should "not update an invoice when no params" do
+      invoice = Invoice.new(@client, 123)
+      assert_false(invoice.save)
     end
 
     should "update an invoice" do
-      invoice = Invoice.new(@client, 1234)
-      invoice.notes = 'Test'
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"id":123,"closed":true}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      invoice = Invoice.new(@client, 123)
+      invoice.closed = true
       assert_true(invoice.save)
+
+      assert_true(invoice.closed)
+    end
+
+    should "list all invoices" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('[{"id":123,"number":"INV-0001"}]')
+      mockResponse.stubs(:headers).returns(:x_total_count => 15, :link => '<https://api.invoiced.com/invoices?per_page=25&page=1>; rel="self", <https://api.invoiced.com/invoices?per_page=25&page=1>; rel="first", <https://api.invoiced.com/invoices?per_page=25&page=1>; rel="last"')
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      invoices, metadata = @client.Invoice.list
+
+      assert_instance_of(Array, invoices)
+      assert_equal(1, invoices.length)
+      assert_equal(123, invoices[0].id)
+
+      assert_instance_of(Invoiced::List, metadata)
+      assert_equal(15, metadata.total_count)
+    end
+
+    should "delete an invoice" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(204)
+      mockResponse.stubs(:body).returns('')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      invoice = Invoice.new(@client, 123)
+      assert_true(invoice.delete)
     end
 
     should "send an invoice" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('[{"id":4567,"email":"test@example.com"}]')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
       invoice = Invoice.new(@client, 1234)
       emails = invoice.send
+
+      assert_instance_of(Array, emails)
+      assert_equal(1, emails.length)
+      assert_instance_of(Invoiced::Email, emails[0])
+      assert_equal(4567, emails[0].id)
     end
 
     should "pay an invoice" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"paid":true}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
       invoice = Invoice.new(@client, 1234)
       assert_true(invoice.pay)
-    end
 
-    should "delete an invoice" do
-      invoie = Invoice.new(@client, 1234)
-      assert_true(invoice.delete)
+      assert_true(invoice.paid)
     end
   end
 end

data/test/invoiced/invoiced_test.rb

@@ -10,15 +10,158 @@ module Invoiced
   		assert_equal('api_key', client.api_key)
   	end
 
-  	should "perform a request" do
-  		client = Invoiced::Client.new('api_key')
+  	should "perform a get request" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"test":true}')
+      mockResponse.stubs(:headers).returns(:Header => "test")
+
+      # not used
+      expectedParameters = {
+        :method => "GET",
+        :url => "https://api.invoiced.com/invoices?envelope=0&test=property&filter[levels]=work",
+        :headers => {
+          :authorization => "Basic dGVzdDo=",
+          :content_type => "application/json",
+          :user_agent => "Invoiced Ruby/#{Invoiced::VERSION}"
+        },
+        :payload => nil
+      }
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+  		client = Invoiced::Client.new('test')
   		params = {
   			"test" => "property",
   			"filter" => {
   				"levels" => "work"
   			}
   		}
-  		client.request("GET", "/invoices", params)
+  		response = client.request("GET", "/invoices", params)
+
+      expectedResponse = {
+        :code => 200,
+        :headers => {
+          :Header => "test"
+        },
+        :body => {
+          :test => true
+        }
+      }
+      assert_equal(expectedResponse, response)
   	end
+
+    should "perform a post request" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(204)
+      mockResponse.stubs(:headers).returns(:Header => "test")
+
+      # not used
+      expectedParameters = {
+        :method => "POST",
+        :url => "https://api.invoiced.com/invoices?envelope=0&test=property&filter[levels]=work",
+        :headers => {
+          :authorization => "Basic dGVzdDo=",
+          :content_type => "application/json",
+          :user_agent => "Invoiced Ruby/#{Invoiced::VERSION}"
+        },
+        :payload => '{"test":"property"}'
+      }
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      client = Invoiced::Client.new('test')
+      params = {
+        "test" => "property"
+      }
+      response = client.request("POST", "/invoices", params)
+
+      expectedResponse = {
+        :code => 204,
+        :headers => {
+          :Header => "test"
+        },
+        :body => nil
+      }
+      assert_equal(expectedResponse, response)
+    end
+
+    should "handle a request exception" do
+      RestClient::Request.any_instance.expects(:execute).raises(RestClient::Exception.new)
+
+      client = Invoiced::Client.new('test')
+
+      assert_raise Invoiced::ApiConnectionError do
+        client.request("POST", "/invoices")
+      end
+    end
+
+    should "handle an invalid request error" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(400)
+      mockResponse.stubs(:body).returns('{"error":true}')
+
+      ex = RestClient::ExceptionWithResponse.new
+      ex.response = mockResponse
+
+      RestClient::Request.any_instance.expects(:execute).raises(ex)
+
+      client = Invoiced::Client.new('test')
+
+      assert_raise Invoiced::InvalidRequestError do
+        client.request("POST", "/invoices")
+      end
+    end
+
+    should "handle an authentication error" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(401)
+      mockResponse.stubs(:body).returns('{"error":true}')
+
+      ex = RestClient::ExceptionWithResponse.new
+      ex.response = mockResponse
+
+      RestClient::Request.any_instance.expects(:execute).raises(ex)
+
+      client = Invoiced::Client.new('test')
+
+      assert_raise Invoiced::AuthenticationError do
+        client.request("POST", "/invoices")
+      end
+    end
+
+    should "handle an api error" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(500)
+      mockResponse.stubs(:body).returns('{"error":true}')
+
+      ex = RestClient::ExceptionWithResponse.new
+      ex.response = mockResponse
+
+      RestClient::Request.any_instance.expects(:execute).raises(ex)
+
+      client = Invoiced::Client.new('test')
+
+      assert_raise Invoiced::ApiError do
+        client.request("POST", "/invoices")
+      end
+    end
+
+    should "handle an api error with invalid json" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(500)
+      mockResponse.stubs(:body).returns('not valid json')
+
+      ex = RestClient::ExceptionWithResponse.new
+      ex.response = mockResponse
+
+      RestClient::Request.any_instance.expects(:execute).raises(ex)
+
+      client = Invoiced::Client.new('test')
+
+      assert_raise Invoiced::ApiError do
+        client.request("POST", "/invoices")
+      end
+    end
   end
 end

data/test/invoiced/object_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Invoiced
+  class ObjectTest < Test::Unit::TestCase
+  	should "create an invoiced object" do
+  		client = Client.new("test")
+
+  		object = Object.new(client, 123, {:name => "Pied Piper"})
+
+  		assert_equal(client, object.client)
+  		assert_equal("{\n  \"name\": \"Pied Piper\",\n  \"id\": 123\n}", object.to_s)
+  		assert_equal("#<#{object.class}:0x#{object.object_id.to_s(16)} id=123> JSON: {\n  \"name\": \"Pied Piper\",\n  \"id\": 123\n}", object.inspect)
+  		assert_equal("{\"name\":\"Pied Piper\",\"id\":123}", object.to_json)
+  		assert_equal({:name => "Pied Piper", :id => 123}, object.to_hash)
+
+  		object.each do |value|
+  			# NOP
+  		end
+  	end
+
+    should "throw exception when retrieving with no id" do
+      assert_raise ArgumentError do
+  		client = Client.new "test"
+
+  		object = Object.new client
+
+        object.retrieve nil
+      end
+    end
+
+    should "add and remove accessors" do
+  		client = Client.new("test")
+
+  		object = Object.new(client, 123, {:name => "Pied Piper"})
+
+  		assert_equal(123, object.id)
+  		assert_equal("Pied Piper", object.name)
+  		assert_equal("Pied Piper", object["name"])
+
+  		object.name = "Renamed"
+  		assert_equal("Renamed", object.name)
+
+  		object["name"] = "Pied Piper"
+  		assert_equal("Pied Piper", object["name"])
+
+  		assert_equal([:name, :id], object.keys)
+  		assert_equal(["Pied Piper", 123], object.values)
+
+  		object.refresh_from({:id => 123, :notes => "...."})
+
+  		# the name attribute should no longer be available
+  		assert_equal("....", object.notes)
+  		assert_raise NoMethodError do
+  			object.name
+  		end
+	end
+
+	should "raise exception when setting missing attribute" do
+  		client = Client.new("test")
+
+  		object = Object.new(client, 123)
+
+		assert_raise NoMethodError do
+			object.non_existent_method
+		end
+	end
+
+	should "raise exception when setting empty string" do
+  		client = Client.new("test")
+
+  		object = Object.new(client, 123, {:name => "Pied Piper"})
+
+		assert_raise ArgumentError do
+			object.name = ""
+		end
+	end
+
+	should "raise exception when attempting to set permanent attribute" do
+  		client = Client.new("test")
+
+  		object = Object.new(client, 123)
+
+		assert_raise NoMethodError do
+			object.id = "fail"
+		end
+	end
+  end
+end

data/test/invoiced/transaction_test.rb

@@ -3,36 +3,115 @@ require File.expand_path('../../test_helper', __FILE__)
 module Invoiced
   class TransactionTest < Test::Unit::TestCase
     should "create a transaction" do
-      transaction = @client.Transaction.create({:invoice => 123, :amount => 800})
-    end
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('{"id":123,"amount":100}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
 
-  	should "list all transactions" do
-      @client.Transaction.list
-  	end
+      transaction = @client.Transaction.create({:amount => 800})
+
+      assert_instance_of(Invoiced::Transaction, transaction)
+      assert_equal(123, transaction.id)
+      assert_equal(100, transaction.amount)
+    end
 
     should "retrieve a transaction" do
-      transaction = @client.Transaction.retrieve(1234)
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"id":123,"amount":100}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      transaction = @client.Transaction.retrieve(123)
+
+      assert_instance_of(Invoiced::Transaction, transaction)
+      assert_equal(123, transaction.id)
+      assert_equal(100, transaction.amount)
+    end
+
+    should "not update a transaction when no params" do
+      transaction = Transaction.new(@client, 123)
+      assert_false(transaction.save)
     end
 
     should "update a transaction" do
-      transaction = Transaction.new(@client, 1234)
-      transaction.notes = 'Update'
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('{"id":123,"sent":true}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      transaction = Transaction.new(@client, 123)
+      transaction.sent = true
       assert_true(transaction.save)
+
+      assert_true(transaction.sent)
+    end
+
+    should "list all transactions" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(200)
+      mockResponse.stubs(:body).returns('[{"id":123,"amount":100}]')
+      mockResponse.stubs(:headers).returns(:x_total_count => 15, :link => '<https://api.invoiced.com/transactions?per_page=25&page=1>; rel="self", <https://api.invoiced.com/transactions?per_page=25&page=1>; rel="first", <https://api.invoiced.com/transactions?per_page=25&page=1>; rel="last"')
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      transactions, metadata = @client.Transaction.list
+
+      assert_instance_of(Array, transactions)
+      assert_equal(1, transactions.length)
+      assert_equal(123, transactions[0].id)
+
+      assert_instance_of(Invoiced::List, metadata)
+      assert_equal(15, metadata.total_count)
+    end
+
+    should "delete a transaction" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(204)
+      mockResponse.stubs(:body).returns('')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
+      transaction = Transaction.new(@client, 123)
+      assert_true(transaction.delete)
     end
 
     should "send a payment receipt" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('[{"id":4567,"email":"test@example.com"}]')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
       transaction = Transaction.new(@client, 1234)
       emails = transaction.send
+
+      assert_instance_of(Array, emails)
+      assert_equal(1, emails.length)
+      assert_instance_of(Invoiced::Email, emails[0])
+      assert_equal(4567, emails[0].id)
     end
 
     should "refund a transaction" do
+      mockResponse = mock('RestClient::Response')
+      mockResponse.stubs(:code).returns(201)
+      mockResponse.stubs(:body).returns('{"id":456}')
+      mockResponse.stubs(:headers).returns({})
+
+      RestClient::Request.any_instance.expects(:execute).returns(mockResponse)
+
       transaction = Transaction.new(@client, 1234)
       refund = transaction.refund({:amount => 800})
-    end
 
-    should "delete a transaction" do
-      transaction = Transaction.new(@client, 1234)
-      assert_true(transaction.delete)
+      assert_instance_of(Invoiced::Transaction, refund)
+      assert_equal(456, refund.id)
     end
   end
 end

data/test/invoiced/util_test.rb

@@ -10,11 +10,19 @@ module Invoiced
         params = {
           "test" => "property",
           "filter" => {
-            "levels" => "work"
-          }
+            "levels" => "work",
+            "nesting" => {
+              "works" => true
+            }
+          },
+          "array" => [
+              "should",
+              {"also" => true},
+              ["work"]
+          ]
         }
 
-        assert_equal("test=property&filter[levels]=work", Util.uri_encode(params))
+        assert_equal("test=property&filter[levels]=work&filter[nesting][works]=true&array[]=should&array[][also]=true&array[]=work", Util.uri_encode(params))
     end
 
     should "create a Customer object" do

data/test/test_helper.rb

@@ -1,3 +1,15 @@
+require 'simplecov'
+require 'simplecov-console'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::Console,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter 'test/'
+end
+
 require 'invoiced'
 require 'test/unit'
 require 'mocha/setup'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invoiced
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Jared King
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-15 00:00:00.000000000 Z
+date: 2015-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -124,6 +124,7 @@ files:
 - lib/invoiced.rb
 - lib/invoiced/customer.rb
 - lib/invoiced/email.rb
+- lib/invoiced/error/api_connection_error.rb
 - lib/invoiced/error/api_error.rb
 - lib/invoiced/error/authentication_error.rb
 - lib/invoiced/error/error_base.rb
@@ -141,8 +142,10 @@ files:
 - lib/invoiced/util.rb
 - lib/invoiced/version.rb
 - test/invoiced/customer_test.rb
+- test/invoiced/error_test.rb
 - test/invoiced/invoice_test.rb
 - test/invoiced/invoiced_test.rb
+- test/invoiced/object_test.rb
 - test/invoiced/transaction_test.rb
 - test/invoiced/util_test.rb
 - test/test_helper.rb
@@ -172,8 +175,10 @@ specification_version: 4
 summary: Ruby client library for the Invoiced API
 test_files:
 - test/invoiced/customer_test.rb
+- test/invoiced/error_test.rb
 - test/invoiced/invoice_test.rb
 - test/invoiced/invoiced_test.rb
+- test/invoiced/object_test.rb
 - test/invoiced/transaction_test.rb
 - test/invoiced/util_test.rb
 - test/test_helper.rb