xero_gateway-float 2.0.15

data/test/unit/account_test.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class AccountTest < Test::Unit::TestCase
+  # Tests that an account can be converted into XML that Xero can understand, and then converted back to an account
+  def test_build_and_parse_xml
+    account = create_test_account
+    
+    # Generate the XML message
+    account_as_xml = account.to_xml
+
+    # Parse the XML message and retrieve the account element
+    account_element = REXML::XPath.first(REXML::Document.new(account_as_xml), "/Account")
+
+    # Build a new account from the XML
+    result_account = XeroGateway::Account.from_xml(account_element)
+    
+    # Check the account details
+    assert_equal account, result_account
+  end
+  
+  def test_build_and_parse_xml_for_bank_accounts
+    account = create_test_account(:type => 'BANK', :currency_code => 'NZD')
+    account_as_xml = account.to_xml
+    assert_match 'CurrencyCode', account_as_xml.to_s
+
+    account_element = REXML::XPath.first(REXML::Document.new(account_as_xml), "/Account")
+    result_account = XeroGateway::Account.from_xml(account_element)
+    assert_equal 'BANK', result_account.type
+    assert_equal 'NZD', result_account.currency_code
+    assert_equal account, result_account
+  end
+  
+  private
+  
+  def create_test_account(options={})
+    account = XeroGateway::Account.new(:account_id => "57cedda9")
+    account.code = "200"
+    account.name = "Sales"
+    account.type = options[:type] || "REVENUE"
+    account.tax_type = "OUTPUT"
+    account.description = "Income from any normal business activity"
+    account.enable_payments_to_account = false
+    account.currency_code = options[:currency_code] if options[:currency_code]
+
+    account
+  end
+end

data/test/unit/bank_transaction_test.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class BankTransactionTest < Test::Unit::TestCase
+  include TestHelper
+
+  context "creating test bank transactions" do
+    should "work" do
+      bank_transaction = create_test_bank_transaction
+
+      # test transaction defaults
+      assert_equal 'RECEIVE', bank_transaction.type
+      assert_kind_of Date, bank_transaction.date
+      assert_equal '12345', bank_transaction.reference
+      assert_equal 'ACTIVE', bank_transaction.status
+
+      # Test the contact defaults.
+      contact = bank_transaction.contact
+      assert_equal '00000000-0000-0000-0000-000000000000', contact.contact_id
+      assert_equal 'CONTACT NAME', contact.name
+
+      # Test address defaults.
+      assert_equal 'STREET', contact.address.address_type
+      assert_equal 'LINE 1 OF THE ADDRESS', contact.address.line_1
+
+      # Test phone defaults.
+      assert_equal('DEFAULT', contact.phone.phone_type)
+      assert_equal('12345678', contact.phone.number)
+
+      # Test the line_item defaults.
+      line_item = bank_transaction.line_items.first
+      assert_equal('A LINE ITEM', line_item.description)
+      assert_equal('200', line_item.account_code)
+      assert_equal(BigDecimal.new('100'), line_item.unit_amount)
+      assert_equal(BigDecimal.new('12.5'), line_item.tax_amount)
+    end
+
+    should "allow overriding transaction defaults" do
+      assert_equal 'SPEND', create_test_bank_transaction(:type => 'SPEND').type
+    end
+  end
+
+  context "adding line items" do
+    setup do
+      @bank_transaction = create_test_bank_transaction({}, {}, nil) # no line_items
+    end
+
+    should "work" do
+      assert_equal(0, @bank_transaction.line_items.size)
+
+      line_item_params = {:description => "Test Item 1", :unit_amount => 100}
+
+      # Test adding line item by hash
+      line_item = @bank_transaction.add_line_item(line_item_params)
+      assert_kind_of(XeroGateway::LineItem, line_item)
+      assert_equal(line_item_params[:description], line_item.description)
+      assert_equal(line_item_params[:unit_amount], line_item.unit_amount)
+      assert_equal(1, @bank_transaction.line_items.size)
+
+      # Test adding line item by XeroGateway::LineItem
+      line_item = @bank_transaction.add_line_item(line_item_params)
+      assert_kind_of(XeroGateway::LineItem, line_item)
+      assert_equal(line_item_params[:description], line_item.description)
+      assert_equal(line_item_params[:unit_amount], line_item.unit_amount)
+      assert_equal(2, @bank_transaction.line_items.size)
+
+      # Test that pushing anything else into add_line_item fails.
+      ["invalid", 100, nil, []].each do | invalid_object |
+        assert_raise(XeroGateway::Invoice::InvalidLineItemError) { @bank_transaction.add_line_item(invalid_object) }
+        assert_equal(2, @bank_transaction.line_items.size)
+      end
+    end
+  end
+
+
+  context "building and parsing XML" do
+    should "work vice versa" do
+      bank_transaction = create_test_bank_transaction
+      bank_transaction_as_xml = bank_transaction.to_xml
+      bank_transaction_element = REXML::XPath.first(REXML::Document.new(bank_transaction_as_xml), "/BankTransaction")
+
+      # checking for mandatory fields
+      assert_xml_field bank_transaction_element, 'Type', :value => 'RECEIVE'
+      assert_xml_field bank_transaction_element, 'Date'
+      assert_xml_field bank_transaction_element, 'Reference', :value => '12345'
+      assert_xml_field bank_transaction_element, 'Status', :value => 'ACTIVE'
+      assert_xml_field bank_transaction_element, 'Contact', :value => 'CONTACT NAME'
+      assert_xml_field bank_transaction_element, 'LineItems', :value => 'A LINE ITEM'
+      assert_xml_field bank_transaction_element, 'BankAccount'
+
+      parsed_bank_transaction = XeroGateway::BankTransaction.from_xml(bank_transaction_element)
+      assert_equal(bank_transaction, parsed_bank_transaction)
+    end
+
+    should "work for optional params" do
+      bank_transaction = create_test_bank_transaction(:url => 'http://example.com?with=params&and=more')
+      bank_transaction_element = REXML::XPath.first(REXML::Document.new(bank_transaction.to_xml), "/BankTransaction")
+
+      assert_xml_field bank_transaction_element, 'Url', :value => 'http://example.com\?with=params&amp;and=more'
+
+      parsed_bank_transaction = XeroGateway::BankTransaction.from_xml(bank_transaction_element)
+      assert_equal 'http://example.com?with=params&and=more', parsed_bank_transaction.url
+    end
+
+    should "ignore missing contact" do
+      bank_transaction = create_test_bank_transaction
+      bank_transaction.contact = nil
+      bank_transaction.to_xml
+    end
+
+    should "ignore missing bank account" do
+      bank_transaction = create_test_bank_transaction
+      bank_transaction.bank_account = nil
+      bank_transaction.to_xml
+    end
+  end
+
+private
+
+  def assert_xml_field(xml, field_name, options={})
+    assert_match /#{field_name}/, xml.to_s, "Didn't find the field #{field_name} in the XML document!"
+    if options[:value]
+      assert_match /#{field_name}.*#{options[:value]}.*#{field_name}/, xml.to_s, "The field #{field_name} was expected to be '#{options[:value]}'!"
+    end
+  end
+
+end

data/test/unit/contact_test.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ContactTest < Test::Unit::TestCase
+  def setup
+    @schema = LibXML::XML::Schema.document(LibXML::XML::Document.file(File.join(File.dirname(__FILE__), '../xsd/create_contact.xsd')))
+  end
+  
+  # Tests that the XML generated from a contact object validates against the Xero XSD
+  def test_build_xml
+    contact = create_test_contact
+    
+    message = contact.to_xml
+
+    # Check that the document matches the XSD
+    assert LibXML::XML::Parser.string(message).parse.validate_schema(@schema), "The XML document generated did not validate against the XSD"
+  end
+  
+  # Tests that a contact can be converted into XML that Xero can understand, and then converted back to a contact
+  def test_build_and_parse_xml
+    contact = create_test_contact
+    
+    # Generate the XML message
+    contact_as_xml = contact.to_xml
+
+    # Parse the XML message and retrieve the contact element
+    contact_element = REXML::XPath.first(REXML::Document.new(contact_as_xml), "/Contact")
+
+    # Build a new contact from the XML
+    result_contact = XeroGateway::Contact.from_xml(contact_element)
+    
+    # Check the contact details
+    assert_equal contact, result_contact
+  end
+  
+  # Test Contact#add_address helper creates a valid XeroGateway::Contact object with the passed in values
+  # and appends it to the Contact#addresses attribute.
+  def test_add_address_helper
+    contact = create_test_contact
+    assert_equal(1, contact.addresses.size)
+    
+    new_values = {
+      :address_type => 'POBOX',
+      :line_1 => 'NEW LINE 1',
+      :line_2 => 'NEW LINE 2',
+      :line_3 => 'NEW LINE 3',
+      :line_4 => 'NEW LINE 4',
+      :city => 'NEW CITY',
+      :region => 'NEW REGION',
+      :post_code => '5555',
+      :country => 'Australia'
+    }
+    contact.add_address(new_values)
+    
+    assert_equal(2, contact.addresses.size)
+    assert_kind_of(XeroGateway::Address, contact.addresses.last)
+    new_values.each { |k,v| assert_equal(v, contact.addresses.last.send("#{k}")) }
+  end
+
+  # Test Contact#add_phone helper creates a valid XeroGateway::Phone object with the passed in values
+  # and appends it to the Contact#phones attribute.
+  def test_add_address_helper
+    contact = create_test_contact
+    assert_equal(1, contact.phones.size)
+    
+    new_values = {
+      :phone_type => 'MOBILE',
+      :country_code => '61',
+      :area_code => '406',
+      :number => '123456'
+    }
+    contact.add_phone(new_values)
+    
+    assert_equal(2, contact.phones.size)
+    assert_kind_of(XeroGateway::Phone, contact.phones.last)
+    new_values.each { |k,v| assert_equal(v, contact.phones.last.send("#{k}")) }
+  end  
+  
+  
+  private
+  
+  def create_test_contact
+    contact = XeroGateway::Contact.new(:contact_id => "55555")
+    contact.contact_number = "aaa111"
+    contact.name = "CONTACT NAME"
+    contact.email = "someone@somewhere.com"
+    contact.address.address_type = "THE ADDRESS TYPE FOR THE CONTACT"
+    contact.address.line_1 = "LINE 1 OF THE ADDRESS"
+    contact.address.line_2 = "LINE 2 OF THE ADDRESS"
+    contact.address.line_3 = "LINE 3 OF THE ADDRESS"
+    contact.address.line_4 = "LINE 4 OF THE ADDRESS"
+    contact.phone.number = "12345"
+    contact.is_customer = true
+    contact.is_supplier = true
+
+    contact
+  end
+end

data/test/unit/credit_note_test.rb

@@ -0,0 +1,284 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class CreditNoteTest < Test::Unit::TestCase
+  
+  # Tests that a credit note can be converted into XML that Xero can understand, and then converted back to a credit note
+  def test_build_and_parse_xml
+    credit_note = create_test_credit_note
+    
+    # Generate the XML message
+    credit_note_as_xml = credit_note.to_xml
+
+    # Parse the XML message and retrieve the credit_note element
+    credit_note_element = REXML::XPath.first(REXML::Document.new(credit_note_as_xml), "/CreditNote")
+
+    # Build a new credit_note from the XML
+    result_credit_note = XeroGateway::CreditNote.from_xml(credit_note_element)
+
+    assert_equal(credit_note, result_credit_note)
+  end
+  
+  # Tests the sub_total calculation and that setting it manually doesn't modify the data.
+  def test_credit_note_sub_total_calculation
+    credit_note = create_test_credit_note
+    line_item = credit_note.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_sub_total = credit_note.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.line_amount }
+    assert_equal(expected_sub_total, credit_note.sub_total)
+    
+    # Change the sub_total and check that it doesn't modify anything.
+    credit_note.sub_total = expected_sub_total * 10
+    assert_equal(expected_sub_total, credit_note.sub_total)
+    
+    # Change the amount of the first line item and make sure that 
+    # everything still continues to add up.
+    line_item.unit_amount = line_item.unit_amount + 10
+    assert_not_equal(expected_sub_total, credit_note.sub_total)
+    expected_sub_total = credit_note.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.line_amount }
+    assert_equal(expected_sub_total, credit_note.sub_total)
+  end
+  
+  # Tests the total_tax calculation and that setting it manually doesn't modify the data.
+  def test_credit_note_sub_total_calculation
+    credit_note = create_test_credit_note
+    line_item = credit_note.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_total_tax = credit_note.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.tax_amount }
+    assert_equal(expected_total_tax, credit_note.total_tax)
+    
+    # Change the total_tax and check that it doesn't modify anything.
+    credit_note.total_tax = expected_total_tax * 10
+    assert_equal(expected_total_tax, credit_note.total_tax)
+    
+    # Change the tax_amount of the first line item and make sure that 
+    # everything still continues to add up.
+    line_item.tax_amount = line_item.tax_amount + 10
+    assert_not_equal(expected_total_tax, credit_note.total_tax)
+    expected_total_tax = credit_note.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.tax_amount }
+    assert_equal(expected_total_tax, credit_note.total_tax)
+  end
+
+  # Tests the total calculation and that setting it manually doesn't modify the data.
+  def test_credit_note_sub_total_calculation
+    credit_note = create_test_credit_note
+    line_item = credit_note.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_total = credit_note.sub_total + credit_note.total_tax
+    assert_equal(expected_total, credit_note.total)
+    
+    # Change the total and check that it doesn't modify anything.
+    credit_note.total = expected_total * 10
+    assert_equal(expected_total, credit_note.total)
+    
+    # Change the quantity of the first line item and make sure that 
+    # everything still continues to add up.
+    line_item.quantity = line_item.quantity + 5
+    assert_not_equal(expected_total, credit_note.total)
+    expected_total = credit_note.sub_total + credit_note.total_tax
+    assert_equal(expected_total, credit_note.total)
+  end
+
+  # Tests that the LineItem#line_amount calculation is working correctly.
+  def test_line_amount_calculation
+    credit_note = create_test_credit_note
+    line_item = credit_note.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_amount = line_item.quantity * line_item.unit_amount
+    assert_equal(expected_amount, line_item.line_amount)
+    
+    # Change the line_amount and check that it doesn't modify anything.
+    line_item.line_amount = expected_amount * 10
+    assert_equal(expected_amount, line_item.line_amount)
+    
+    # Change the quantity and check that the line_amount has been updated.
+    quantity = line_item.quantity + 2
+    line_item.quantity = quantity
+    assert_not_equal(expected_amount, line_item.line_amount)
+    assert_equal(quantity * line_item.unit_amount, line_item.line_amount)
+  end
+  
+  # Ensure that the totalling methods don't raise exceptions, even when
+  # credit_note.line_items is empty.
+  def test_totalling_methods_when_line_items_empty
+    credit_note = create_test_credit_note
+    credit_note.line_items = []
+    
+    assert_nothing_raised(Exception) {
+      assert_equal(BigDecimal.new('0'), credit_note.sub_total)
+      assert_equal(BigDecimal.new('0'), credit_note.total_tax)
+      assert_equal(BigDecimal.new('0'), credit_note.total)
+    }
+  end
+  
+  def test_type_helper_methods
+    # Test accounts receivable credit_notes.
+    credit_note = create_test_credit_note({:type => 'ACCRECCREDIT'})
+    assert_equal(true,  credit_note.accounts_receivable?, "Accounts RECEIVABLE credit_note doesn't think it is.")
+    assert_equal(false, credit_note.accounts_payable?,    "Accounts RECEIVABLE credit_note thinks it's payable.")
+    
+    # Test accounts payable credit_notes.
+    credit_note = create_test_credit_note({:type => 'ACCPAYCREDIT'})
+    assert_equal(false, credit_note.accounts_receivable?, "Accounts PAYABLE credit_note doesn't think it is.")
+    assert_equal(true,  credit_note.accounts_payable?,    "Accounts PAYABLE credit_note thinks it's receivable.")
+  end
+  
+  
+  # Make sure that the create_test_credit_note method is working correctly
+  # with all the defaults and overrides.
+  def test_create_test_credit_note_defaults_working
+    credit_note = create_test_credit_note
+    
+    # Test credit_note defaults.
+    assert_equal('ACCRECCREDIT', credit_note.type)
+    assert_kind_of(Date, credit_note.date)
+    assert_equal('12345', credit_note.credit_note_number)
+    assert_equal('MY REFERENCE FOR THIS CREDIT NOTE', credit_note.reference)
+    assert_equal("Exclusive", credit_note.line_amount_types)
+    
+    # Test the contact defaults.
+    assert_equal('00000000-0000-0000-0000-000000000000', credit_note.contact.contact_id)
+    assert_equal('CONTACT NAME', credit_note.contact.name)
+    
+    # Test address defaults.
+    assert_equal('DEFAULT', credit_note.contact.address.address_type)
+    assert_equal('LINE 1 OF THE ADDRESS', credit_note.contact.address.line_1)
+    
+    # Test phone defaults.
+    assert_equal('DEFAULT', credit_note.contact.phone.phone_type)
+    assert_equal('12345678', credit_note.contact.phone.number)
+    
+    # Test the line_item defaults.
+    assert_equal('A LINE ITEM', credit_note.line_items.first.description)
+    assert_equal('200', credit_note.line_items.first.account_code)
+    assert_equal(BigDecimal.new('100'), credit_note.line_items.first.unit_amount)
+    assert_equal(BigDecimal.new('12.5'), credit_note.line_items.first.tax_amount)
+
+    # Test overriding an credit_note parameter (assume works for all).
+    credit_note = create_test_credit_note({:type => 'ACCPAYCREDIT'})
+    assert_equal('ACCPAYCREDIT', credit_note.type)
+    
+    # Test overriding a contact/address/phone parameter (assume works for all).
+    credit_note = create_test_credit_note({}, {:name => 'OVERRIDDEN NAME', :address => {:line_1 => 'OVERRIDDEN LINE 1'}, :phone => {:number => '999'}})
+    assert_equal('OVERRIDDEN NAME', credit_note.contact.name)
+    assert_equal('OVERRIDDEN LINE 1', credit_note.contact.address.line_1)
+    assert_equal('999', credit_note.contact.phone.number)
+    
+    # Test overriding line_items with hash.
+    credit_note = create_test_credit_note({}, {}, {:description => 'OVERRIDDEN LINE ITEM'})
+    assert_equal(1, credit_note.line_items.size)
+    assert_equal('OVERRIDDEN LINE ITEM', credit_note.line_items.first.description)
+    assert_equal(BigDecimal.new('100'), credit_note.line_items.first.unit_amount)
+    
+    # Test overriding line_items with array of 2 line_items.
+    credit_note = create_test_credit_note({}, {}, [
+      {:description => 'OVERRIDDEN ITEM 1'},
+      {:description => 'OVERRIDDEN ITEM 2', :account_code => '200', :unit_amount => BigDecimal.new('200'), :tax_amount => '25.0'}
+    ])
+    assert_equal(2, credit_note.line_items.size)
+    assert_equal('OVERRIDDEN ITEM 1', credit_note.line_items[0].description)
+    assert_equal(BigDecimal.new('100'), credit_note.line_items[0].unit_amount)
+    assert_equal('OVERRIDDEN ITEM 2', credit_note.line_items[1].description)
+    assert_equal(BigDecimal.new('200'), credit_note.line_items[1].unit_amount)
+  end
+  
+  def test_auto_creation_of_associated_contact
+    credit_note = create_test_credit_note({}, nil) # no contact
+    assert_nil(credit_note.instance_variable_get("@contact"))
+    
+    new_contact = credit_note.contact
+    assert_kind_of(XeroGateway::Contact, new_contact)
+  end
+  
+  def test_add_line_item
+    credit_note = create_test_credit_note({}, {}, nil) # no line_items
+    assert_equal(0, credit_note.line_items.size)
+    
+    line_item_params = {:description => "Test Item 1", :unit_amount => 100}
+    
+    # Test adding line item by hash
+    line_item = credit_note.add_line_item(line_item_params)
+    assert_kind_of(XeroGateway::LineItem, line_item)
+    assert_equal(line_item_params[:description], line_item.description)
+    assert_equal(line_item_params[:unit_amount], line_item.unit_amount)
+    assert_equal(1, credit_note.line_items.size)
+    
+    # Test adding line item by XeroGateway::LineItem
+    line_item = credit_note.add_line_item(line_item_params)
+    assert_kind_of(XeroGateway::LineItem, line_item)
+    assert_equal(line_item_params[:description], line_item.description)
+    assert_equal(line_item_params[:unit_amount], line_item.unit_amount)
+    assert_equal(2, credit_note.line_items.size)
+
+    # Test that pushing anything else into add_line_item fails.
+    ["invalid", 100, nil, []].each do | invalid_object |
+      assert_raise(XeroGateway::CreditNote::InvalidLineItemError) { credit_note.add_line_item(invalid_object) }
+      assert_equal(2, credit_note.line_items.size)
+    end
+  end
+  
+  private
+    
+  def create_test_credit_note(credit_note_params = {}, contact_params = {}, line_item_params = [])
+    unless credit_note_params.nil?
+      credit_note_params = {
+        :type => 'ACCRECCREDIT',
+        :date => Date.today,
+        :credit_note_number => '12345',
+        :reference => "MY REFERENCE FOR THIS CREDIT NOTE",
+        :line_amount_types => "Exclusive"
+      }.merge(credit_note_params)
+    end
+    credit_note = XeroGateway::CreditNote.new(credit_note_params || {})
+    
+    unless contact_params.nil?
+      # Strip out :address key from contact_params to use as the default address.
+      stripped_address = {
+        :address_type => 'DEFAULT',
+        :line_1 => 'LINE 1 OF THE ADDRESS'
+      }.merge(contact_params.delete(:address) || {})
+    
+      # Strip out :phone key from contact_params to use at the default phone.
+      stripped_phone = {
+        :phone_type => 'DEFAULT',
+        :number => '12345678'
+      }.merge(contact_params.delete(:phone) || {})
+    
+      contact_params = {
+        :contact_id => '00000000-0000-0000-0000-000000000000', # Just any valid GUID
+        :name => "CONTACT NAME",
+        :first_name => "Bob",
+        :last_name => "Builder"
+      }.merge(contact_params)
+    
+      # Create credit_note.contact from contact_params.
+      credit_note.contact = XeroGateway::Contact.new(contact_params)
+      credit_note.contact.address = XeroGateway::Address.new(stripped_address)
+      credit_note.contact.phone = XeroGateway::Phone.new(stripped_phone)
+    end
+    
+    unless line_item_params.nil?
+      line_item_params = [line_item_params].flatten # always use an array, even if only a single hash passed in
+    
+      # At least one line item, make first have some defaults.
+      line_item_params << {} if line_item_params.size == 0
+      line_item_params[0] = {
+        :description => "A LINE ITEM",
+        :account_code => "200",
+        :unit_amount => BigDecimal.new("100"),
+        :tax_amount => BigDecimal.new("12.5"),
+        :tracking => XeroGateway::TrackingCategory.new(:name => "blah", :options => "hello")
+      }.merge(line_item_params[0])
+    
+      # Create credit_note.line_items from line_item_params
+      line_item_params.each do | line_item |
+        credit_note.add_line_item(line_item)
+      end
+    end
+    
+    credit_note
+  end
+end