xero_gateway 2.0.2

data/lib/xero_gateway/tracking_category.rb

@@ -0,0 +1,62 @@
+module XeroGateway
+  class TrackingCategory
+    attr_accessor :name, :options
+    
+    def initialize(params = {})
+      @options = []
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def option
+       options[0] if options.size == 1
+    end
+        
+    def to_xml(b = Builder::XmlMarkup.new)
+      b.TrackingCategory {
+        b.Name self.name
+        b.Options {
+          if self.options.is_a?(Array)
+            self.options.each do |option|
+              b.Option {
+                b.Name option
+              }
+            end
+          else
+            b.Option {
+              b.Name self.options.to_s
+            }            
+          end
+        }
+      }
+    end
+    
+    # When a tracking category is serialized as part of an invoice it may only have a single
+    # option, and the Options tag is omitted
+    def to_xml_for_invoice_messages(b = Builder::XmlMarkup.new)
+      b.TrackingCategory {
+        b.Name self.name
+        b.Option self.options.is_a?(Array) ? self.options.first : self.options.to_s 
+      }      
+    end
+    
+    def self.from_xml(tracking_category_element)
+      tracking_category = TrackingCategory.new
+      tracking_category_element.children.each do |element|
+        case(element.name)
+          when "Name" then tracking_category.name = element.text
+          when "Options" then element.children.each {|option| tracking_category.options << option.children.first.text}
+        end
+      end
+      tracking_category              
+    end  
+    
+    def ==(other)
+      [:name, :options].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end      
+  end
+end

data/lib/xero_gateway.rb

@@ -0,0 +1,33 @@
+require "cgi"
+require "uri"
+require "net/https"
+require "rexml/document"
+require "builder"
+require "bigdecimal"
+require "oauth"
+require 'oauth/signature/rsa/sha1'
+require "forwardable"
+require "active_support/inflector"
+
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'http_encoding_helper')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'http')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'dates')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'money')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'response')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'account')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'accounts_list')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'tracking_category')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'contact')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'line_item')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'payment')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'invoice')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'address')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'phone')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'organisation')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'tax_rate')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'currency')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'error')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'oauth')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'exceptions')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'gateway')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'private_app')

data/test/integration/accounts_list_test.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AccountsListTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+    
+    # Always stub out calls for this integration test as we need to be able to control the data.
+    @gateway.xero_url = "DUMMY_URL"    
+    
+    @gateway.stubs(:http_get).with {|client, url, params| url =~ /Accounts$/ }.returns(get_file_as_string("accounts.xml"))
+  end
+  
+  def test_get_accounts_list
+    accounts_list = @gateway.get_accounts_list
+    assert_not_equal(0, accounts_list.accounts.size)
+  end  
+  
+  # Make sure that the list is loaded when finding things.
+  def test_raise_error_on_not_loaded
+    accounts_list = @gateway.get_accounts_list(false)
+    assert_equal(false, accounts_list.loaded?)
+    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list[200] }
+    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list.find_by_code(200) }
+    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list.find_all_by_type('EXPENSE') }
+    assert_raise(XeroGateway::AccountsList::AccountsListNotLoadedError) { accounts_list.find_all_by_tax_type('OUTPUT') }
+  end
+  
+  # Test simple lookup by account code (from cache).
+  def test_simple_lookup_by_account_code
+    accounts_list = @gateway.get_accounts_list
+    assert_equal(true, accounts_list.loaded?)
+    
+    # Load data in the stubbed response.
+    expected_accounts = accounts_as_array
+    
+    # Make sure that every single expected account exists in the cached lookup hash.
+    expected_accounts.each do | expected_account |
+      found_account = accounts_list.find_by_code(expected_account.code)
+      assert_kind_of(XeroGateway::Account, found_account)
+      assert(expected_account == found_account, "Found account does not match expected account.")
+
+      found_account_shortcut = accounts_list[expected_account.code]
+      assert_kind_of(XeroGateway::Account, found_account_shortcut)
+      assert(expected_account == found_account_shortcut, "Found account does not match expected account (shortcut).")
+    end
+  end
+  
+  # Test finding accounts by their account type (from cache).
+  def test_lookup_by_account_type
+    accounts_list = @gateway.get_accounts_list
+    assert_equal(true, accounts_list.loaded?)
+    
+    # Load data in the stubbed response.
+    expected_accounts = accounts_as_array
+
+    # Get all the unique account types present in the expected accounts data along with their counts.
+    unique_types = expected_accounts.inject({}) do | list, account | 
+      list[account.type] = 0 if list[account.type].nil?
+      list[account.type] += 1
+      list
+    end
+    
+    assert_not_equal(0, unique_types)
+    unique_types.each do | account_type, count |
+      found_accounts = accounts_list.find_all_by_type(account_type)
+      assert_equal(count, found_accounts.size)
+      found_accounts.each do | found_account | 
+        assert_kind_of(XeroGateway::Account, found_account)
+        assert_equal(account_type, found_account.type)
+      end
+    end    
+  end
+
+  # Test finding accounts by their tax type (from cache).
+  def test_lookup_by_tax_type
+    accounts_list = @gateway.get_accounts_list
+    assert_equal(true, accounts_list.loaded?)
+    
+    # Load data in the stubbed response.
+    expected_accounts = accounts_as_array
+
+    # Get all the unique tax types present in the expected accounts data along with their counts.
+    unique_types = expected_accounts.inject({}) do | list, account | 
+      list[account.tax_type] = 0 if list[account.tax_type].nil?
+      list[account.tax_type] += 1
+      list
+    end
+    
+    assert_not_equal(0, unique_types)
+    unique_types.each do | tax_type, count |
+      found_accounts = accounts_list.find_all_by_tax_type(tax_type)
+      assert_equal(count, found_accounts.size)
+      found_accounts.each do | found_account | 
+        assert_kind_of(XeroGateway::Account, found_account)
+        assert_equal(tax_type, found_account.tax_type)
+      end
+    end    
+  end
+  
+  private
+  
+    def accounts_as_array
+      response = @gateway.__send__(:parse_response, get_file_as_string("accounts.xml"))
+      response.accounts
+    end
+  
+end

data/test/integration/create_contact_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreateContactTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+    
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+      
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Contacts$/ }.returns(get_file_as_string("contact.xml"))          
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /Contacts$/ }.returns(get_file_as_string("contact.xml"))          
+    end
+  end
+  
+  def test_create_contact
+    example_contact = dummy_contact.dup
+    
+    result = @gateway.create_contact(example_contact)
+    assert_valid_contact_save_response(result, example_contact)
+  end
+  
+  def test_create_from_contact
+    example_contact = dummy_contact.dup
+    
+    contact = @gateway.build_contact(example_contact)
+    result = contact.create
+    assert_valid_contact_save_response(result, example_contact)
+  end
+
+  def test_update_from_contact
+    example_contact = dummy_contact.dup
+    
+    contact = @gateway.build_contact(example_contact)
+    contact.create # need to create first so we have a ContactID
+    
+    result = contact.update
+    assert_valid_contact_save_response(result, example_contact)
+  end
+  
+  def test_save_from_contact
+    example_contact = dummy_contact.dup
+    
+    contact = @gateway.build_contact(example_contact)
+    result = contact.save
+    assert_valid_contact_save_response(result, example_contact)
+  end    
+  
+  def test_create_contact_valid
+    example_contact = dummy_contact.dup
+    assert_equal true, example_contact.valid?, "contact is invalid - errors:\n\t#{example_contact.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
+  end
+  
+  private
+  
+    def assert_valid_contact_save_response(result, example_contact)
+      assert_kind_of XeroGateway::Response, result
+      assert result.success?
+      assert !result.contact.contact_id.nil?
+      assert !result.request_xml.nil?
+      assert !result.response_xml.nil?
+      assert_equal result.contact.name, example_contact.name
+      assert example_contact.contact_id =~ GUID_REGEX      
+    end
+end

data/test/integration/create_invoice_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreateInvoiceTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+    
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+      
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("create_invoice.xml"))          
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("invoice.xml"))          
+    end
+  end
+  
+  def test_create_invoice
+    example_invoice = dummy_invoice.dup
+    
+    result = @gateway.create_invoice(example_invoice)
+    assert_valid_invoice_save_response(result, example_invoice)
+  end
+  
+  def test_create_from_invoice
+    example_invoice = dummy_invoice.dup
+    
+    invoice = @gateway.build_invoice(example_invoice)
+    result = invoice.create
+    assert_valid_invoice_save_response(result, example_invoice)
+  end
+  
+  def test_create_invoice_valid
+    example_invoice = dummy_invoice.dup
+    assert_equal true, example_invoice.valid?, "invoice is invalid - errors:\n\t#{example_invoice.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
+  end
+  
+  private
+  
+    def assert_valid_invoice_save_response(result, example_invoice)
+      assert_kind_of XeroGateway::Response, result
+      assert result.success?
+      assert !result.request_xml.nil?
+      assert !result.response_xml.nil?
+      assert !result.invoice.invoice_id.nil?
+      assert result.invoice.invoice_number == example_invoice.invoice_number
+      assert example_invoice.invoice_id =~ GUID_REGEX
+    end
+    
+end

data/test/integration/get_accounts_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetAccountsTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+    
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+      
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Accounts$/ }.returns(get_file_as_string("accounts.xml"))          
+    end
+  end
+  
+  def test_get_accounts
+    result = @gateway.get_accounts
+    assert result.success?
+    assert !result.response_xml.nil?
+    assert result.accounts.size > 0
+    assert_equal XeroGateway::Account, result.accounts.first.class
+  end
+end

data/test/integration/get_contact_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetContactTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+      
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Contacts\/[^\/]+$/ }.returns(get_file_as_string("contact.xml"))          
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Contacts$/ }.returns(get_file_as_string("contact.xml"))          
+    end
+  end
+  
+  def test_get_contact
+    # Make sure there is an contact in Xero to retrieve
+    contact = @gateway.create_contact(dummy_contact).contact
+    flunk "get_contact could not be tested because create_contact failed" if contact.nil?
+
+    result = @gateway.get_contact_by_id(contact.contact_id)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert_equal result.contact.name, contact.name
+  end
+end

data/test/integration/get_contacts_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetContactsTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+    
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+      
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Contacts$/ }.returns(get_file_as_string("contacts.xml"))          
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Contacts$/ }.returns(get_file_as_string("contact.xml"))          
+    end
+  end
+  
+  def test_get_contacts
+    # Make sure there is an contact in Xero to retrieve
+    contact = @gateway.create_contact(dummy_contact).contact
+    flunk "get_contacts could not be tested because create_contact failed" if contact.nil?
+
+    result = @gateway.get_contacts
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert result.contacts.collect {|c| c.contact_id}.include?(contact.contact_id)
+  end  
+  
+  # Make sure that a reference to gateway is passed when the get_contacts response is parsed.
+  def test_get_contacts_gateway_reference
+    result = @gateway.get_contacts
+    assert(result.success?)
+    assert_not_equal(0, result.contacts.size)
+    
+    result.contacts.each do | contact |
+      assert(contact.gateway === @gateway)
+    end
+  end
+  
+end

data/test/integration/get_currencies_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetCurrenciesTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
+    
+    if STUB_XERO_CALLS
+      @gateway.xero_url = "DUMMY_URL"
+      
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Currencies$/ }.returns(get_file_as_string("currencies.xml"))          
+    end
+  end
+  
+  def test_get_currencies
+    result = @gateway.get_currencies
+    assert result.success?
+    assert !result.response_xml.nil?
+    
+    assert result.currencies.size > 0
+    assert_equal XeroGateway::Currency, result.currencies.first.class
+    assert_equal "NZD", result.currencies.first.code
+  end
+end