tlconnor-xero_gateway 1.0.3 → 1.0.4

data/lib/xero_gateway/response.rb

@@ -13,7 +13,6 @@ module XeroGateway
     
     def initialize(params = {})
       params.each do |k,v|
-        self.instance_variable_set("@#{k}", v)  ## create and initialize an instance variable for this key/value pair
         self.send("#{k}=", v)
       end
       
@@ -29,4 +28,4 @@ module XeroGateway
       errors.blank? ? nil : errors[0]
     end
   end
-end
+end

data/lib/xero_gateway/tracking_category.rb

@@ -5,21 +5,15 @@ module XeroGateway
     def initialize(params = {})
       @options = []
       params.each do |k,v|
-        self.instance_variable_set("@#{k}", v)  ## create and initialize an instance variable for this key/value pair
         self.send("#{k}=", v)
       end
     end
     
-    def ==(other)
-      [:name, :options].each do |field|
-        return false if send(field) != other.send(field)
-      end
-      return true
+    def option
+       options[0] if options.size == 1
     end
-    
-    def to_xml
-      b = Builder::XmlMarkup.new
-      
+        
+    def to_xml(b = Builder::XmlMarkup.new)
       b.TrackingCategory {
         b.Name self.name
         b.Options {
@@ -41,6 +35,13 @@ module XeroGateway
         end
       end
       tracking_category              
-    end    
+    end  
+    
+    def ==(other)
+      [:name, :options].each do |field|
+        return false if send(field) != other.send(field)
+      end
+      return true
+    end      
   end
-end
+end

data/test/integration/accounts_list_test.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class AccountsListTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @gateway = XeroGateway::Gateway.new(
+      :customer_key => CUSTOMER_KEY,
+      :api_key => API_KEY
+    )
+    
+    # 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 {|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

@@ -13,17 +13,57 @@ class CreateContactTest < Test::Unit::TestCase
       @gateway.xero_url = "DUMMY_URL"
       
       @gateway.stubs(:http_put).with {|url, body, params| url =~ /contact$/ }.returns(get_file_as_string("contact.xml"))          
+      @gateway.stubs(:http_post).with {|url, body, params| url =~ /contact$/ }.returns(get_file_as_string("contact.xml"))          
     end
   end
   
   def test_create_contact
-    example_contact = dummy_contact
+    example_contact = dummy_contact.dup
     
     result = @gateway.create_contact(example_contact)
-    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_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

@@ -13,17 +13,40 @@ class CreateInvoiceTest < Test::Unit::TestCase
       @gateway.xero_url = "DUMMY_URL"
       
       @gateway.stubs(:http_put).with {|url, body, params| url =~ /invoice$/ }.returns(get_file_as_string("invoice.xml"))          
+      @gateway.stubs(:http_post).with {|url, body, params| url =~ /invoice$/ }.returns(get_file_as_string("invoice.xml"))          
     end
   end
   
   def test_create_invoice
-    example_invoice = dummy_invoice
+    example_invoice = dummy_invoice.dup
     
     result = @gateway.create_invoice(example_invoice)
-    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_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/test_helper.rb

@@ -20,6 +20,9 @@ module TestHelper
   
   API_KEY = ENV["API_KEY"] unless defined? API_KEY
   CUSTOMER_KEY = ENV["CUSTOMER_KEY"] unless defined? CUSTOMER_KEY
+  
+  # Helper constant for checking regex
+  GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ unless defined?(GUID_REGEX)
 
   
   def dummy_invoice
@@ -28,22 +31,18 @@ module TestHelper
        :due_date => Date.today + 20,
        :invoice_number => STUB_XERO_CALLS ? "INV-0001" : "#{Time.now.to_f}",
        :reference => "YOUR REFERENCE (NOT NECESSARILY UNIQUE!)",
-       :sub_total => 1000,
-       :total_tax => 125,
-       :total => 1125
      })
      invoice.contact = dummy_contact
      invoice.line_items << XeroGateway::LineItem.new(
        :description => "THE DESCRIPTION OF THE LINE ITEM",
        :unit_amount => 1000,
        :tax_amount => 125,
-       :line_amount => 1000,
        :tracking_category => "THE TRACKING CATEGORY FOR THE LINE ITEM",
        :tracking_option => "THE TRACKING OPTION FOR THE LINE ITEM"
      )
      invoice
   end
-  
+      
   def dummy_contact
     unique_id = Time.now.to_f
     contact = XeroGateway::Contact.new(:name => STUB_XERO_CALLS ? "CONTACT NAME" : "THE NAME OF THE CONTACT #{unique_id}")

data/test/unit/contact_test.rb

@@ -32,6 +32,49 @@ class ContactTest < Test::Unit::TestCase
     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
   

data/test/unit/invoice_test.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(__FILE__), '../test_helper.rb')
 
 class InvoiceTest < Test::Unit::TestCase
+  
   def setup
     @schema = LibXML::XML::Schema.document(LibXML::XML::Document.file(File.join(File.dirname(__FILE__), '../xsd/create_invoice.xsd')))
   end
@@ -31,33 +32,225 @@ class InvoiceTest < Test::Unit::TestCase
     assert_equal(invoice, result_invoice)
   end
   
+  # Tests the sub_total calculation and that setting it manually doesn't modify the data.
+  def test_invoice_sub_total_calculation
+    invoice = create_test_invoice
+    line_item = invoice.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_sub_total = invoice.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.line_amount }
+    assert_equal(expected_sub_total, invoice.sub_total)
+    
+    # Change the sub_total and check that it doesn't modify anything.
+    invoice.sub_total = expected_sub_total * 10
+    assert_equal(expected_sub_total, invoice.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, invoice.sub_total)
+    expected_sub_total = invoice.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.line_amount }
+    assert_equal(expected_sub_total, invoice.sub_total)
+  end
   
-  private
+  # Tests the total_tax calculation and that setting it manually doesn't modify the data.
+  def test_invoice_sub_total_calculation
+    invoice = create_test_invoice
+    line_item = invoice.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_total_tax = invoice.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.tax_amount }
+    assert_equal(expected_total_tax, invoice.total_tax)
+    
+    # Change the total_tax and check that it doesn't modify anything.
+    invoice.total_tax = expected_total_tax * 10
+    assert_equal(expected_total_tax, invoice.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, invoice.total_tax)
+    expected_total_tax = invoice.line_items.inject(BigDecimal.new('0')) { | sum, line_item | line_item.tax_amount }
+    assert_equal(expected_total_tax, invoice.total_tax)
+  end
+
+  # Tests the total calculation and that setting it manually doesn't modify the data.
+  def test_invoice_sub_total_calculation
+    invoice = create_test_invoice
+    line_item = invoice.line_items.first
+    
+    # Make sure that everything adds up to begin with.
+    expected_total = invoice.sub_total + invoice.total_tax
+    assert_equal(expected_total, invoice.total)
+    
+    # Change the total and check that it doesn't modify anything.
+    invoice.total = expected_total * 10
+    assert_equal(expected_total, invoice.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, invoice.total)
+    expected_total = invoice.sub_total + invoice.total_tax
+    assert_equal(expected_total, invoice.total)
+  end
+
+  # Tests that the LineItem#line_amount calculation is working correctly.
+  def test_line_amount_calculation
+    invoice = create_test_invoice
+    line_item = invoice.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
+  # invoice.line_items is empty.
+  def test_totalling_methods_when_line_items_empty
+    invoice = create_test_invoice
+    invoice.line_items = []
+    
+    assert_nothing_raised(Exception) {
+      assert_equal(BigDecimal.new('0'), invoice.sub_total)
+      assert_equal(BigDecimal.new('0'), invoice.total_tax)
+      assert_equal(BigDecimal.new('0'), invoice.total)
+    }
+  end
+  
+  def test_invoice_type_helper_methods
+    # Test accounts receivable invoices.
+    invoice = create_test_invoice({:invoice_type => 'ACCREC'})
+    assert_equal(true,  invoice.accounts_receivable?, "Accounts RECEIVABLE invoice doesn't think it is.")
+    assert_equal(false, invoice.accounts_payable?,    "Accounts RECEIVABLE invoice thinks it's payable.")
+    
+    # Test accounts payable invoices.
+    invoice = create_test_invoice({:invoice_type => 'ACCPAY'})
+    assert_equal(false, invoice.accounts_receivable?, "Accounts PAYABLE invoice doesn't think it is.")
+    assert_equal(true,  invoice.accounts_payable?,    "Accounts PAYABLE invoice thinks it's receivable.")
+  end
   
-  def create_test_invoice
-    invoice = XeroGateway::Invoice.new(:invoice_type => "THE INVOICE TYPE")
-    invoice.date = Time.now
-    invoice.due_date = Time.now + 10
-    invoice.invoice_number = "12345"
-    invoice.reference = "MY REFERENCE FOR THIS INVOICE"
-    invoice.includes_tax = false
-    invoice.sub_total = BigDecimal.new("1000")
-    invoice.total_tax = BigDecimal.new("125")
-    invoice.total = BigDecimal.new("1125")
-    
-    invoice.contact = XeroGateway::Contact.new(:contact_id => 55555)
-    invoice.contact.name = "CONTACT NAME"
-    invoice.contact.address.address_type = "THE ADDRESS TYPE FOR THE CONTACT"
-    invoice.contact.address.line_1 = "LINE 1 OF THE ADDRESS"
-    invoice.contact.phone.number = "12345"
-    
-    invoice.line_items << XeroGateway::LineItem.new({
+  
+  # Make sure that the create_test_invoice method is working correctly
+  # with all the defaults and overrides.
+  def test_create_test_invoice_defaults_working
+    invoice = create_test_invoice
+    
+    # Test invoice defaults.
+    assert_equal('ACCREC', invoice.invoice_type)
+    assert_kind_of(Time, invoice.date)
+    assert_kind_of(Time, invoice.due_date)
+    assert_equal('12345', invoice.invoice_number)
+    assert_equal('MY REFERENCE FOR THIS INVOICE', invoice.reference)
+    assert_equal(false, invoice.includes_tax)
+    
+    # Test the contact defaults.
+    assert_equal('00000000-0000-0000-0000-000000000000', invoice.contact.contact_id)
+    assert_equal('CONTACT NAME', invoice.contact.name)
+    
+    # Test address defaults.
+    assert_equal('DEFAULT', invoice.contact.address.address_type)
+    assert_equal('LINE 1 OF THE ADDRESS', invoice.contact.address.line_1)
+    
+    # Test phone defaults.
+    assert_equal('DEFAULT', invoice.contact.phone.phone_type)
+    assert_equal('12345678', invoice.contact.phone.number)
+    
+    # Test the line_item defaults.
+    assert_equal('A LINE ITEM', invoice.line_items.first.description)
+    assert_equal('200', invoice.line_items.first.account_code)
+    assert_equal(BigDecimal.new('100'), invoice.line_items.first.unit_amount)
+    assert_equal(BigDecimal.new('12.5'), invoice.line_items.first.tax_amount)
+
+    # Test overriding an invoice parameter (assume works for all).
+    invoice = create_test_invoice({:invoice_type => 'ACCPAY'})
+    assert_equal('ACCPAY', invoice.invoice_type)
+    
+    # Test overriding a contact/address/phone parameter (assume works for all).
+    invoice = create_test_invoice({}, {:name => 'OVERRIDDEN NAME', :address => {:line_1 => 'OVERRIDDEN LINE 1'}, :phone => {:number => '999'}})
+    assert_equal('OVERRIDDEN NAME', invoice.contact.name)
+    assert_equal('OVERRIDDEN LINE 1', invoice.contact.address.line_1)
+    assert_equal('999', invoice.contact.phone.number)
+    
+    # Test overriding line_items with hash.
+    invoice = create_test_invoice({}, {}, {:description => 'OVERRIDDEN LINE ITEM'})
+    assert_equal(1, invoice.line_items.size)
+    assert_equal('OVERRIDDEN LINE ITEM', invoice.line_items.first.description)
+    assert_equal(BigDecimal.new('100'), invoice.line_items.first.unit_amount)
+    
+    # Test overriding line_items with array of 2 line_items.
+    invoice = create_test_invoice({}, {}, [
+      {:description => 'OVERRIDDEN ITEM 1'},
+      {:description => 'OVERRIDDEN ITEM 2', :account_code => '200', :unit_amount => BigDecimal.new('200'), :tax_amount => '25.0'}
+    ])
+    assert_equal(2, invoice.line_items.size)
+    assert_equal('OVERRIDDEN ITEM 1', invoice.line_items[0].description)
+    assert_equal(BigDecimal.new('100'), invoice.line_items[0].unit_amount)
+    assert_equal('OVERRIDDEN ITEM 2', invoice.line_items[1].description)
+    assert_equal(BigDecimal.new('200'), invoice.line_items[1].unit_amount)
+  end
+  
+  private
+    
+  def create_test_invoice(invoice_params = {}, contact_params = {}, line_item_params = [])
+    invoice_params = {
+      :invoice_type => 'ACCREC',
+      :date => Time.now,
+      :due_date => Time.now + (10 * 24 * 3600), # 10 days in the future
+      :invoice_number => '12345',
+      :reference => "MY REFERENCE FOR THIS INVOICE",
+      :includes_tax => false
+    }.merge(invoice_params)
+    invoice = XeroGateway::Invoice.new(invoice_params)
+    
+    # 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"
+    }.merge(contact_params)
+    
+    # Create invoice.contact from contact_params.
+    invoice.contact = XeroGateway::Contact.new(contact_params)
+    invoice.contact.address = XeroGateway::Address.new(stripped_address)
+    invoice.contact.phone = XeroGateway::Phone.new(stripped_phone)
+    
+    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"),
-      :line_amount => BigDecimal.new("125")
-    })
+      :tax_amount => BigDecimal.new("12.5")        
+    }.merge(line_item_params[0])
+    
+    # Create invoice.line_items from line_item_params
+    line_item_params.each do | line_item |
+      invoice.line_items << XeroGateway::LineItem.new(line_item)
+    end
+    
     invoice
   end
 end