xero_gateway-float 2.0.15

data/lib/xero_gateway/tax_rate.rb

@@ -0,0 +1,63 @@
+module XeroGateway
+  class TaxRate
+    
+    unless defined? ATTRS
+      ATTRS = {
+        "Name"                  => :string, 
+        "TaxType"               => :string,
+        "CanApplyToAssets"      => :boolean,
+        "CanApplyToEquity"      => :boolean,
+        "CanApplyToExpenses"    => :boolean,
+        "CanApplyToLiabilities" => :boolean,
+        "CanApplyToRevenue"     => :boolean,
+        "DisplayTaxRate"        => :float,
+        "EffectiveRate"         => :float
+      }
+    end
+    
+    attr_accessor *ATTRS.keys.map(&:underscore)
+    
+    def initialize(params = {})
+      params.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+    
+    def ==(other)
+      ATTRS.keys.map(&:underscore).each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end
+    
+    def to_xml
+      b = Builder::XmlMarkup.new
+      
+      b.TaxRate do
+        ATTRS.keys.each do |attr|
+          eval("b.#{attr} '#{self.send(attr.underscore.to_sym)}'")
+        end
+      end
+    end
+    
+    def self.from_xml(tax_rate_element)
+      TaxRate.new.tap do |tax_rate|
+        tax_rate_element.children.each do |element|
+        
+          attribute             = element.name
+          underscored_attribute = element.name.underscore
+        
+          raise "Unknown attribute: #{attribute}" unless ATTRS.keys.include?(attribute)
+        
+          case (ATTRS[attribute])
+            when :boolean then  tax_rate.send("#{underscored_attribute}=", (element.text == "true"))
+            when :float   then  tax_rate.send("#{underscored_attribute}=", element.text.to_f)
+            else                tax_rate.send("#{underscored_attribute}=", element.text)
+          end
+          
+        end
+      end
+    end
+    
+  end
+end

data/lib/xero_gateway/tracking_category.rb

@@ -0,0 +1,87 @@
+# Tacking categories look like:
+#
+# <TrackingCategory>
+#   <Name>Region</Name>
+#   <Status>ACTIVE</Status>
+#   <TrackingCategoryID>e4a95e64-ebaa-401e-81cf-b625c7532d01</TrackingCategoryID>
+#   <Options>
+#     <Option>
+#       <TrackingOptionID>ea7f7b6a-0d22-4d5c-9317-54542a10215e</TrackingOptionID>
+#       <Name>North</Name>
+#     </Option>
+#     <Option>
+#       <TrackingOptionID>8e8b8d7b-fa75-4b24-b429-8cbc1a21af23</TrackingOptionID>
+#       <Name>South</Name>
+#     </Option>
+#   </Options>
+# </TrackingCategory>
+#
+module XeroGateway
+  class TrackingCategory
+    attr_accessor :tracking_category_id, :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.TrackingCategoryID tracking_category_id unless tracking_category_id.nil?
+        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.TrackingCategoryID self.tracking_category_id unless tracking_category_id.nil?
+        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 "TrackingCategoryID" then tracking_category.tracking_category_id = element.text
+          when "Name" then tracking_category.name = element.text
+          when "Options" then
+            element.children.each do |option_child|
+              tracking_category.options << option_child.children.detect {|c| c.name == "Name"}.text
+            end
+          when "Option" then tracking_category.options << element.text
+        end
+      end
+      tracking_category              
+    end  
+    
+    def ==(other)
+      [:tracking_category_id, :name, :options].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end      
+  end
+end

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_bank_transaction_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreateBankTransactionTest < 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 =~ /BankTransactions$/ }.returns(get_file_as_string("create_bank_transaction.xml"))
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /BankTransactions$/ }.returns(get_file_as_string("bank_transaction.xml"))
+    end
+  end
+
+  def test_create_bank_transaction
+    example_bank_transaction = create_test_bank_transaction.dup
+
+    result = @gateway.create_bank_transaction(example_bank_transaction)
+    assert_kind_of XeroGateway::Response, result
+    assert result.success?
+    assert !result.request_xml.nil?
+    assert !result.response_xml.nil?
+    assert !result.bank_transaction.bank_transaction_id.nil?
+    assert example_bank_transaction.bank_transaction_id =~ GUID_REGEX
+  end
+
+  def test_create_bank_transaction_valid
+    example_bank_transaction = create_test_bank_transaction.dup
+    assert_equal true, example_bank_transaction.valid?,
+      "bank_transaction is invalid - errors:\n\t#{example_bank_transaction.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
+  end
+
+  private
+
+
+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_credit_note_test.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreateCreditNoteTest < 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 =~ /CreditNotes$/ }.returns(get_file_as_string("create_credit_note.xml"))          
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /CreditNotes$/ }.returns(get_file_as_string("credit_note.xml"))          
+    end
+  end
+  
+  def test_create_credit_note
+    example_credit_note = dummy_credit_note.dup
+    
+    result = @gateway.create_credit_note(example_credit_note)
+    assert_valid_credit_note_save_response(result, example_credit_note)
+  end
+  
+  def test_create_from_credit_note
+    example_credit_note = dummy_credit_note.dup
+    
+    credit_note = @gateway.build_credit_note(example_credit_note)
+    result = credit_note.create
+    assert_valid_credit_note_save_response(result, example_credit_note)
+  end
+  
+  def test_create_credit_note_valid
+    example_credit_note = dummy_credit_note.dup
+    assert_equal true, example_credit_note.valid?, "credit_note is invalid - errors:\n\t#{example_credit_note.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
+  end
+  
+  private
+  
+    def assert_valid_credit_note_save_response(result, example_credit_note)
+      assert_kind_of XeroGateway::Response, result
+      assert result.success?
+      assert !result.request_xml.nil?
+      assert !result.response_xml.nil?
+      assert !result.credit_note.credit_note_id.nil?
+      assert result.credit_note.credit_note_number == example_credit_note.credit_note_number
+      assert result.credit_note.credit_note_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