xero_gateway-float 2.0.18 → 2.1.1

data/lib/xero_gateway.rb

@@ -8,6 +8,7 @@ require "oauth"
 require 'oauth/signature/rsa/sha1'
 require "forwardable"
 require "active_support/all"
+require "tempfile"
 
 require File.join(File.dirname(__FILE__), 'oauth', 'oauth_consumer')
 
@@ -27,6 +28,8 @@ 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', 'bank_transaction')
 require File.join(File.dirname(__FILE__), 'xero_gateway', 'credit_note')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'journal_line')
+require File.join(File.dirname(__FILE__), 'xero_gateway', 'manual_journal')
 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')

data/test/integration/accounts_list_test.rb

@@ -21,10 +21,10 @@ class AccountsListTest < Test::Unit::TestCase
   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') }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list[200] }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list.find_by_code(200) }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list.find_all_by_type('EXPENSE') }
+    assert_raise(XeroGateway::AccountsListNotLoadedError) { accounts_list.find_all_by_tax_type('OUTPUT') }
   end
   
   # Test simple lookup by account code (from cache).

data/test/integration/create_invoice_test.rb

@@ -33,6 +33,12 @@ class CreateInvoiceTest < Test::Unit::TestCase
     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
+
+  def test_create_invoice_invalid_with_invalid_invoice_type
+    example_invoice = dummy_invoice.dup
+    example_invoice.invoice_type = "ABC"
+    assert_equal false, example_invoice.valid?
+  end
   
   private
   

data/test/integration/create_manual_journal_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreateManualJournalTest < 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 =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("manual_journal.xml"))
+    end
+  end
+
+  def test_create_manual_journal
+    example_manual_journal = create_test_manual_journal.dup
+
+    result = @gateway.create_manual_journal(example_manual_journal)
+    assert_kind_of XeroGateway::Response, result
+    assert result.success?
+    assert !result.request_xml.nil?
+    assert !result.response_xml.nil?
+    assert !result.manual_journal.manual_journal_id.nil?
+    assert example_manual_journal.manual_journal_id =~ GUID_REGEX
+  end
+
+  def test_create_manual_journal_valid
+    example_manual_journal = create_test_manual_journal.dup
+    assert_equal true, example_manual_journal.valid?,
+      "manual_journal is invalid - errors:\n\t#{example_manual_journal.errors.map { | error | "#{error[0]} #{error[1]}"}.join("\n\t")}"
+  end
+
+end

data/test/integration/create_payments_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class CreatePaymentsTest < 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_put).with {|client, url, params| url =~ /Payments$/ }.returns(get_file_as_string("create_payments.xml"))
+    end
+  end
+
+  def test_create_payment
+    example_invoice = dummy_invoice.dup
+
+    result = @gateway.create_invoice(example_invoice)
+
+    payment = XeroGateway::Payment.new(
+      :invoice_id => result.invoice.invoice_id,
+      :amount     => 500,
+      :reference  => "Test Payment",
+      :date       => Time.now,
+      :code       => "601"
+    )
+
+    result = @gateway.create_payment(payment)
+
+    assert_kind_of XeroGateway::Response, result
+    assert result.success?
+  end
+end

data/test/integration/get_invoice_test.rb

@@ -2,18 +2,25 @@ require File.dirname(__FILE__) + '/../test_helper'
 
 class GetInvoiceTest < Test::Unit::TestCase
   include TestHelper
-  
+
+  INVOICE_GET_URL = /Invoices(\/[0-9a-z\-]+)?$/i
+
   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 =~ /Invoices(\/[0-9a-z\-]+)?$/i }.returns(get_file_as_string("invoice.xml"))              
-      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("create_invoice.xml"))          
+
+      @gateway.stubs(:http_get).with do |client, url, params, headers|
+        url =~ INVOICE_GET_URL && headers["Accept"] == "application/pdf"
+      end.returns(get_file_as_string("get_invoice.pdf"))
+
+      @gateway.stubs(:http_get).with {|client, url, params, headers| url =~ INVOICE_GET_URL && headers["Accept"].blank? }.returns(get_file_as_string("invoice.xml"))
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /Invoices$/ }.returns(get_file_as_string("create_invoice.xml"))
+
     end
   end
-  
+
   def test_get_invoice
     # Make sure there is an invoice in Xero to retrieve
     invoice = @gateway.create_invoice(dummy_invoice).invoice
@@ -21,28 +28,36 @@ class GetInvoiceTest < Test::Unit::TestCase
     result = @gateway.get_invoice(invoice.invoice_id)
     assert result.success?
     assert !result.request_params.nil?
-    assert !result.response_xml.nil?    
+    assert !result.response_xml.nil?
     assert_equal result.invoice.invoice_number, invoice.invoice_number
 
     result = @gateway.get_invoice(invoice.invoice_number)
     assert result.success?
     assert !result.request_params.nil?
-    assert !result.response_xml.nil?    
+    assert !result.response_xml.nil?
     assert_equal result.invoice.invoice_id, invoice.invoice_id
   end
-  
+
   def test_line_items_downloaded_set_correctly
     # Make sure there is an invoice in Xero to retrieve.
     example_invoice = @gateway.create_invoice(dummy_invoice).invoice
-    
+
     # No line items.
     response = @gateway.get_invoice(example_invoice.invoice_id)
     assert_equal(true, response.success?)
-    
+
     invoice = response.invoice
     assert_kind_of(XeroGateway::LineItem, invoice.line_items.first)
     assert_kind_of(XeroGateway::Invoice, invoice)
     assert_equal(true, invoice.line_items_downloaded?)
   end
-  
+
+  def test_get_invoice_pdf
+    # Make sure there is an invoice in Xero to retrieve
+    example_invoice = @gateway.create_invoice(dummy_invoice).invoice
+
+    pdf_tempfile = @gateway.get_invoice(example_invoice.invoice_id, :pdf)
+    assert_equal get_file_as_string("get_invoice.pdf"), File.open(pdf_tempfile.path).read
+  end
+
 end

data/test/integration/get_manual_journal_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetManualJournalTest < 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 =~ /ManualJournals(\/[0-9a-z\-]+)?$/i }.returns(get_file_as_string("manual_journal.xml"))
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+    end
+  end
+
+  def test_get_manual_journal
+    # Make sure there is a manual journal in Xero to retrieve
+    response = @gateway.create_manual_journal(create_test_manual_journal)
+    manual_journal = response.manual_journal
+
+    result = @gateway.get_manual_journal(manual_journal.manual_journal_id)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert_equal result.manual_journal.manual_journal_id, manual_journal.manual_journal_id
+    assert_equal result.manual_journal.narration, manual_journal.narration
+
+    result = @gateway.get_manual_journal(manual_journal.manual_journal_id)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert_equal result.manual_journal.manual_journal_id, manual_journal.manual_journal_id
+  end
+
+  def test_journal_lines_downloaded_set_correctly
+    # Make sure there is a manual journal in Xero to retrieve.
+    example_manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+  
+    # No line items.
+    response = @gateway.get_manual_journal(example_manual_journal.manual_journal_id)
+    assert response.success?
+  
+    manual_journal = response.manual_journal
+    assert_kind_of(XeroGateway::JournalLine, manual_journal.journal_lines.first)
+    assert_kind_of(XeroGateway::ManualJournal, manual_journal)
+    assert manual_journal.journal_lines_downloaded?
+  end
+
+end

data/test/integration/get_manual_journals_test.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class GetManualJournalsTest < Test::Unit::TestCase
+  include TestHelper
+
+  INVALID_MANUAL_JOURNAL_ID = "99999999-9999-9999-9999-999999999999" unless defined?(INVALID_MANUAL_JOURNAL_ID)
+
+  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 =~ /ManualJournals(\/[0-9a-z\-]+)?$/i }.returns(get_file_as_string("manual_journals.xml"))
+      @gateway.stubs(:http_put).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+
+      # Get a manual journal with an invalid ID.
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ Regexp.new("ManualJournals/#{INVALID_MANUAL_JOURNAL_ID}") }.returns(get_file_as_string("manual_journal_not_found_error.xml"))
+    end
+  end
+
+  def test_get_manual_journals
+    # Make sure there is a manual journal in Xero to retrieve
+    manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+
+    result = @gateway.get_manual_journals
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert result.manual_journals.collect {|i| i.narration}.include?(manual_journal.narration)
+    assert result.manual_journals.collect {|i| i.manual_journal_id}.include?(manual_journal.manual_journal_id)
+  end
+
+  def test_get_manual_journals_with_modified_since_date
+    # Create a test manual journal
+    @gateway.create_manual_journal(create_test_manual_journal)
+
+    # Check that it is returned
+    result = @gateway.get_manual_journals(:modified_since => Date.today - 1)
+    assert result.success?
+    assert !result.request_params.nil?
+    assert !result.response_xml.nil?
+    assert result.request_params.keys.include?(:ModifiedAfter) # make sure the flag was sent
+  end
+
+  def test_journal_lines_downloaded_set_correctly
+    # No line items.
+    response = @gateway.get_manual_journals
+    assert_equal(true, response.success?)
+
+    manual_journal = response.manual_journals.first
+    assert_kind_of(XeroGateway::ManualJournal, manual_journal)
+    assert !manual_journal.journal_lines_downloaded?
+  end
+
+  # Make sure that a reference to gateway is passed when the get_manual_journals response is parsed.
+  def test_get_manual_journals_gateway_reference
+    result = @gateway.get_manual_journals
+    assert(result.success?)
+    assert_not_equal(0, result.manual_journals.size)
+
+    result.manual_journals.each do |manual_journal|
+      assert(manual_journal.gateway === @gateway)
+    end
+  end
+
+  # Test to make sure that we correctly error when a manual journal doesn't have an ID.
+  # This should usually never be ecountered.
+  def test_to_ensure_that_a_manual_journal_with_invalid_id_errors
+    # Make sure there is a manual journal to retrieve, even though we will mangle it later.
+    manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+
+    result = @gateway.get_manual_journals
+    assert_equal(true, result.success?)
+
+    manual_journal = result.manual_journals.first
+    assert !manual_journal.journal_lines_downloaded?
+
+    # Mangle invoice_id to invalid one.
+    manual_journal.manual_journal_id = INVALID_MANUAL_JOURNAL_ID
+
+    # Make sure we fail here.
+    journal_lines = nil
+    assert_raise(XeroGateway::ManualJournalNotFoundError) { journal_lines = manual_journal.journal_lines }
+    assert_nil(journal_lines)
+  end
+
+end

data/test/integration/update_manual_journal_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class UpdateManualJournalTest < 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 =~ /ManualJournals$/ }.returns(get_file_as_string("create_manual_journal.xml"))
+      @gateway.stubs(:http_post).with {|client, url, body, params| url =~ /ManualJournals$/ }.returns(get_file_as_string("manual_journal.xml"))
+    end
+  end
+
+  def test_update_manual_journal
+    manual_journal = @gateway.create_manual_journal(create_test_manual_journal).manual_journal
+
+    today = Date.today
+    manual_journal.date = today
+
+    result = @gateway.update_manual_journal(manual_journal)
+
+    assert result.success?
+    assert !result.request_xml.nil?
+    assert !result.response_xml.nil?
+    assert_equal manual_journal.manual_journal_id, result.manual_journal.manual_journal_id
+    assert_equal today, result.manual_journal.date if !STUB_XERO_CALLS
+  end
+end

data/test/test_helper.rb

@@ -6,7 +6,7 @@ require 'shoulda'
 
 require 'libxml'
 
-require File.dirname(__FILE__) + '/../lib/xero_gateway.rb'
+require File.dirname(__FILE__) + '/../lib/xero_gateway.rb' unless defined?(XeroGateway)
 
 module TestHelper
   # The integration tests can be run against the Xero test environment.  You mush have a company set up in the test
@@ -176,4 +176,42 @@ module TestHelper
     contact
   end
 
+  def create_test_manual_journal(params={}, journal_line_params={})
+    params = {      
+      :date       => Date.today,
+      :narration  => 'test narration',
+      :status     => 'POSTED'
+    }.merge(params)
+    manual_journal = XeroGateway::ManualJournal.new(params)
+    add_test_journal_lines(manual_journal, journal_line_params)
+  end
+
+  def add_test_journal_lines(manual_journal, journal_line_params)
+    if journal_line_params
+      journal_line_params = [journal_line_params].flatten # always use an array, even if only a single hash passed in
+
+      # At least one line item, make first have some defaults.
+      journal_line_params << {} if journal_line_params.size == 0
+      journal_line_params[0] = {
+        :description  => "FIRST LINE",
+        :account_code => "200",
+        :line_amount  => BigDecimal.new("100"),
+        :tracking     => XeroGateway::TrackingCategory.new(:name => "blah", :options => "hello")
+      }.merge(journal_line_params[0])
+      params_line_1 = journal_line_params[1] || {}
+      journal_line_params[1] = {
+        :description  => "SECOND LINE",
+        :account_code => "200",
+        :line_amount  => BigDecimal.new("-100"),        
+        :tracking     => XeroGateway::TrackingCategory.new(:name => "blah2", :options => "hello2")
+      }.merge(params_line_1)      
+
+      # Create line_items from line_item_params
+      journal_line_params.each do |journal_line|
+        manual_journal.add_journal_line(journal_line)
+      end
+    end
+    manual_journal
+  end
+
 end

data/test/unit/bank_transaction_test.rb

@@ -65,7 +65,7 @@ class BankTransactionTest < Test::Unit::TestCase
 
       # 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_raise(XeroGateway::InvalidLineItemError) { @bank_transaction.add_line_item(invalid_object) }
         assert_equal(2, @bank_transaction.line_items.size)
       end
     end

data/test/unit/credit_note_test.rb

@@ -215,7 +215,7 @@ class CreditNoteTest < Test::Unit::TestCase
 
     # 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_raise(XeroGateway::InvalidLineItemError) { credit_note.add_line_item(invalid_object) }
       assert_equal(2, credit_note.line_items.size)
     end
   end

data/test/unit/gateway_test.rb

@@ -6,28 +6,28 @@ class GatewayTest < Test::Unit::TestCase
   def setup
     @gateway = XeroGateway::Gateway.new(CONSUMER_KEY, CONSUMER_SECRET)
   end
-  
+
   context "with error handling" do
-    
+
     should "handle token expired" do
       XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("token_expired"), :code => "401"))
-      
+
       assert_raises XeroGateway::OAuth::TokenExpired do
         @gateway.get_accounts
       end
     end
-    
+
     should "handle invalid request tokens" do
       XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_request_token"), :code => "401"))
-      
+
       assert_raises XeroGateway::OAuth::TokenInvalid do
         @gateway.get_accounts
       end
     end
-    
+
     should "handle invalid consumer key" do
      XeroGateway::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_consumer_key"), :code => "401"))
-      
+
       assert_raises XeroGateway::OAuth::TokenInvalid do
         @gateway.get_accounts
       end
@@ -48,10 +48,10 @@ class GatewayTest < Test::Unit::TestCase
         @gateway.get_accounts
       end
     end
-    
+
     should "handle ApiExceptions" do
       XeroGateway::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => get_file_as_string("api_exception.xml"), :code => "400"))
-      
+
       assert_raises XeroGateway::ApiException do
         @gateway.create_invoice(XeroGateway::Invoice.new)
       end
@@ -86,17 +86,17 @@ class GatewayTest < Test::Unit::TestCase
 
       assert_raises XeroGateway::UnparseableResponse do
         @gateway.create_invoice(XeroGateway::Invoice.new)
-      end      
+      end
     end
-    
+
   end
-  
+
   def test_unknown_error_handling
     if STUB_XERO_CALLS
       @gateway.xero_url = "DUMMY_URL"
-      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices\/AN_INVALID_ID$/ }.returns(get_file_as_string("unknown_error.xml"))          
+      @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices\/AN_INVALID_ID$/ }.returns(get_file_as_string("unknown_error.xml"))
     end
-    
+
     result = @gateway.get_invoice("AN_INVALID_ID")
     assert !result.success?
     assert_equal 1, result.errors.size
@@ -109,7 +109,7 @@ class GatewayTest < Test::Unit::TestCase
       @gateway.xero_url = "DUMMY_URL"
       @gateway.stubs(:http_get).with {|client, url, params| url =~ /Invoices\/UNKNOWN_INVOICE_NO$/ }.returns(get_file_as_string("invoice_not_found_error.xml"))
     end
-    
+
     result = @gateway.get_invoice("UNKNOWN_INVOICE_NO")
     assert !result.success?
     assert_equal 1, result.errors.size

data/test/unit/invoice_test.rb

@@ -229,7 +229,7 @@ class InvoiceTest < Test::Unit::TestCase
 
     # Test that pushing anything else into add_line_item fails.
     ["invalid", 100, nil, []].each do | invalid_object |
-      assert_raise(XeroGateway::Invoice::InvalidLineItemError) { invoice.add_line_item(invalid_object) }
+      assert_raise(XeroGateway::InvalidLineItemError) { invoice.add_line_item(invalid_object) }
       assert_equal(2, invoice.line_items.size)
     end
   end
@@ -240,8 +240,9 @@ class InvoiceTest < Test::Unit::TestCase
   end
 
   def test_optional_params
-    invoice = create_test_invoice(:url => 'http://example.com')
+    invoice = create_test_invoice(:url => 'http://example.com', :branding_theme_id => 'a94a78db-5cc6-4e26-a52b-045237e56e6e')
     assert_equal 'http://example.com', invoice.url
+    assert_equal 'a94a78db-5cc6-4e26-a52b-045237e56e6e', invoice.branding_theme_id
   end
 
   private

data/test/unit/manual_journal_test.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ManualJournalTest < Test::Unit::TestCase
+  include TestHelper
+
+  context "creating test manual journals" do
+    should "work" do
+      manual_journal = create_test_manual_journal
+
+      # test transaction defaults
+      assert_equal 'POSTED', manual_journal.status
+      assert_kind_of Date, manual_journal.date
+      assert_equal 'test narration', manual_journal.narration      
+
+      # Test the journal_line defaults.
+      journal_line = manual_journal.journal_lines.first
+      assert_equal('FIRST LINE', journal_line.description)
+      assert_equal('200', journal_line.account_code)
+      assert_equal(BigDecimal.new('100'), journal_line.line_amount)
+    end
+
+    should "allow overriding transaction defaults" do
+      assert_equal 'DRAFT', create_test_manual_journal(:status => 'DRAFT').status
+    end
+  end
+
+  context "adding journal lines" do
+    setup do
+      @manual_journal = create_test_manual_journal
+    end
+
+    should "work" do
+      assert_equal 2, @manual_journal.journal_lines.size
+      assert @manual_journal.valid?
+
+      journal_line_params = {:description => "Test Item 1", :line_amount => 100, :account_code => '200'}
+
+      # Test adding line item by hash
+      journal_line = @manual_journal.add_journal_line(journal_line_params)
+      assert_kind_of(XeroGateway::JournalLine, journal_line)
+      assert_equal(journal_line_params[:description], journal_line.description)
+      assert_equal(journal_line_params[:line_amount], journal_line.line_amount)
+      assert_equal(3, @manual_journal.journal_lines.size)
+
+      # Test adding line item by XeroGateway::JournalLine
+      journal_line = @manual_journal.add_journal_line(journal_line_params)
+      assert_kind_of(XeroGateway::JournalLine, journal_line)
+      assert_equal(journal_line_params[:description], journal_line.description)
+      assert_equal(journal_line_params[:line_amount], journal_line.line_amount)
+      assert_equal(4, @manual_journal.journal_lines.size)
+
+      # Test that having only 1 journal line fails.      
+      @manual_journal.journal_lines = [] 
+      @manual_journal.add_journal_line(journal_line_params)
+      assert !@manual_journal.valid?
+    end
+  end
+
+
+  context "building and parsing XML" do
+    should "work vice versa" do
+      manual_journal = create_test_manual_journal
+      manual_journal_as_xml = manual_journal.to_xml
+      manual_journal_element = REXML::XPath.first(REXML::Document.new(manual_journal_as_xml), "/ManualJournal")
+
+      # checking for mandatory fields      
+      assert_xml_field manual_journal_element, 'Date'
+      assert_xml_field manual_journal_element, 'Narration', :value => 'test narration'
+      assert_xml_field manual_journal_element, 'Status', :value => 'POSTED'            
+
+      parsed_manual_journal = XeroGateway::ManualJournal.from_xml(manual_journal_element)
+      assert_equal(manual_journal, parsed_manual_journal)
+    end
+
+    should "work for optional params" do
+      manual_journal = create_test_manual_journal(:url => 'http://example.com?with=params&and=more')
+      manual_journal_element = REXML::XPath.first(REXML::Document.new(manual_journal.to_xml), "/ManualJournal")
+
+      assert_xml_field manual_journal_element, 'Url', :value => 'http://example.com\?with=params&amp;and=more'
+
+      parsed_manual_journal = XeroGateway::ManualJournal.from_xml(manual_journal_element)
+      assert_equal 'http://example.com?with=params&and=more', parsed_manual_journal.url
+    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!"
+    assert_match /#{field_name}.*#{options[:value]}.*#{field_name}/, xml.to_s, "The field #{field_name} was expected to be '#{options[:value]}'!" if options[:value]    
+  end
+
+end

data/test/unit/payment_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class PaymentTest < Test::Unit::TestCase
+
+  # Tests that a payment can be converted into XML that Xero can understand, and then converted back to a payment
+  def test_build_and_parse_xml
+    payment = create_test_payment
+
+    # Generate the XML message
+    payment_as_xml = payment.to_xml
+
+    # Parse the XML message and retrieve the account element
+    payment_element = REXML::XPath.first(REXML::Document.new(payment_as_xml), "/Payment")
+
+    # Build a new account from the XML
+    result_payment = XeroGateway::Payment.from_xml(payment_element)
+
+    # Check the details
+    assert_equal payment, result_payment
+  end
+
+
+  private
+
+  def create_test_payment
+    XeroGateway::Payment.new.tap do |payment|
+      payment.invoice_id        = "a99a9aaa-9999-99a9-9aa9-aaaaaa9a9999"
+      payment.amount            = 100.0
+      payment.date              = Time.now.beginning_of_day
+      payment.reference         = "Invoice Payment"
+      payment.code              = 200
+    end
+  end
+end