xeroizer-float 2.15.3.1

data/test/unit/models/contact_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class ContactTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @contact = @client.Contact.build
+  end
+  
+  context "contact validators" do
+    
+    should "have a name" do
+      assert_equal(false, @contact.valid?)
+      blank_error = @contact.errors_for(:name).first
+      assert_not_nil(blank_error)
+      assert_equal("can't be blank", blank_error)
+      
+      @contact.name = "SOMETHING"
+      assert_equal(true, @contact.valid?)
+      assert_equal(0, @contact.errors.size)
+    end
+    
+  end
+  
+end

data/test/unit/models/credit_note_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class CreditNoteTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)    
+    mock_api("CreditNotes")
+    @credit_note = @client.CreditNote.first
+  end
+  
+  context "credit note totals" do
+    
+    should "raise error when trying to set totals directly" do
+      assert_raises Xeroizer::SettingTotalDirectlyNotSupported do
+        @credit_note.sub_total = 500.0
+      end
+      assert_raises Xeroizer::SettingTotalDirectlyNotSupported do
+        @credit_note.total_tax = 50.0
+      end
+      assert_raises Xeroizer::SettingTotalDirectlyNotSupported do
+        @credit_note.total = 550.0
+      end
+    end
+        
+    should "large-scale testing from API XML" do
+      credit_notes = @client.CreditNote.all
+      credit_notes.each do | credit_note |
+        assert_equal(credit_note.attributes[:sub_total], credit_note.sub_total)
+        assert_equal(credit_note.attributes[:total_tax], credit_note.total_tax)
+        assert_equal(credit_note.attributes[:total], credit_note.total)
+      end
+    end
+    
+  end
+  
+end

data/test/unit/models/invoice_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class InvoiceTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    mock_api('Invoices')
+    @invoice = @client.Invoice.first
+  end
+
+  def build_valid_authorised_invoice
+    @client.Invoice.build({
+      :type => "ACCREC",
+      :contact => { :name => "ABC Limited" },
+      :status => "AUTHORISED",
+      :date => Date.today,
+      :due_date => Date.today,
+      :line_items => [{
+        :description => "Consulting services as agreed",
+        :quantity => 0.005,
+        :unit_amount => 1,
+        :account_code => 200
+      }]
+    })
+  end
+
+  context "invoice types" do
+    
+    should "have helpers to determine invoice type" do
+      @invoice.type = 'ACCREC'
+      assert_equal(true, @invoice.accounts_receivable?)
+      assert_equal(false, @invoice.accounts_payable?)
+
+      @invoice.type = 'ACCPAY'
+      assert_equal(false, @invoice.accounts_receivable?)
+      assert_equal(true, @invoice.accounts_payable?)
+    end
+    
+  end
+  
+  context "invoice totals" do
+    
+    should "large-scale testing from API XML" do
+      invoices = @client.Invoice.all
+      invoices.each do | invoice |
+        assert_equal(invoice.attributes[:sub_total], invoice.sub_total)
+        assert_equal(invoice.attributes[:total_tax], invoice.total_tax)
+        assert_equal(invoice.attributes[:total], invoice.total)
+      end
+    end
+
+  end
+  
+  context "invoice validations" do
+
+    should "build an invalid invoice if there are no attributes" do
+      assert_equal(false, @client.Invoice.build.valid?)
+    end
+
+    should "build a valid DRAFT invoice with minimal attributes" do
+      invoice = @client.Invoice.build :type => "ACCREC", :contact => { :name => "ABC Limited" }
+      assert_equal(true, invoice.valid?)
+    end
+
+    should "build a invalid AUTHORISED invoice with minimal attributes" do
+      invoice = @client.Invoice.build :type => "ACCREC", :contact => { :name => "ABC Limited" }, :status => "AUTHORISED"
+      assert_equal(false, invoice.valid?)
+    end
+
+    should "build a valid AUTHORISED invoice with complete attributes" do
+      invoice = build_valid_authorised_invoice
+      assert_equal(true, invoice.valid?)
+    end
+
+  end
+
+  context "line items" do
+
+    should "round line item amounts to two decimal places" do
+      invoice = build_valid_authorised_invoice
+      assert_equal(0.01, invoice.line_items.first.line_amount)
+    end
+
+  end
+  
+  context "contact shortcuts" do
+    
+    should "have valid #contact_name and #contact_id without downloading full invoice" do
+      invoices = @client.Invoice.all
+      invoices.each do |invoice|
+        assert_not_equal("", invoice.contact_name)
+        assert_not_equal("", invoice.contact_id)
+        assert_equal(false, invoice.complete_record_downloaded?)
+      end
+    end
+    
+  end
+
+  context "updated date" do
+    should "get the updated date as utc" do
+      invoices = @client.Invoice.all
+      
+      assert_equal(Time.parse("2008-9-16T10:28:51.5Z"), invoices[0].updated_date_utc)
+
+      invoices.each do |invoice|
+        assert invoice.updated_date_utc.utc?, "updated_date_utc should be utc"
+      end
+    end
+  end
+
+
+end

data/test/unit/models/journal_line_test.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+
+class JournalLineTest < Test::Unit::TestCase
+  include TestHelper
+  include Xeroizer::Record
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+  end
+  
+  it "journal_line tracking specified correctly" do
+    journal = @client.Journal.build
+    journal_line = journal.add_journal_line({})
+    
+    journal_line.add_tracking_category(:name => "Name 1", :option => "Option 1")
+    journal_line.add_tracking_category(:name => "Name 2", :option => "Option 2")
+    
+    doc = Nokogiri::XML(journal_line.to_xml)
+    assert_equal 2, doc.xpath("/JournalLine/TrackingCategories/TrackingCategory").size
+  end
+
+end

data/test/unit/models/line_item_sum_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+
+class LineItemSumTest < Test::Unit::TestCase
+  include Xeroizer::Record
+
+  def setup
+    @the_line_items = [
+      LineItem.build({:quantity => 1, :unit_amount => 1.00, :tax_amount => 0.15}, nil),
+      LineItem.build({:quantity => 1, :unit_amount => 1.00, :tax_amount => 0.30}, nil)
+    ]
+  end
+
+  it "sub_total is the sum of the line_amounts" do
+    assert_equal BigDecimal("2.00"), LineItemSum.sub_total(@the_line_items)
+  end
+
+  it "total_tax is the sum of the tax_amounts" do
+    assert_equal BigDecimal("0.45"), LineItemSum.total_tax(@the_line_items)
+  end
+
+  it "total is the sum of sub_total and total_tax" do
+    assert_equal BigDecimal("2.45"), LineItemSum.total(@the_line_items)
+  end
+end

data/test/unit/models/line_item_test.rb

@@ -0,0 +1,70 @@
+require "test_helper"
+
+class LineItemTest < Test::Unit::TestCase
+  include TestHelper
+  include Xeroizer::Record
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+  end
+  
+  it "line_item tracking specified correctly" do
+    invoice = @client.Invoice.build
+    line_item = invoice.add_line_item({:description => "Test Description", :quantity => 1, :unit_amount => 200})
+    
+    line_item.add_tracking(:name => "Name 1", :option => "Option 1")
+    line_item.add_tracking(:name => "Name 2", :option => "Option 2")
+    
+    doc = Nokogiri::XML(line_item.to_xml)
+    assert_equal 2, doc.xpath("/LineItem/Tracking/TrackingCategory").size
+  end
+
+  it "line_amount equals unit_price times quantity" do
+    line_item = LineItem.new(nil)
+
+    line_item.quantity = 1
+    line_item.unit_amount = BigDecimal("1337.00")
+    line_item.tax_amount = BigDecimal("0.15")
+
+    expected = BigDecimal((line_item.quantity * (line_item.unit_amount)).to_s).round(2)
+
+    assert_equal expected.to_s, line_item.line_amount.to_s
+  end
+
+  it "line_amount is zero when quantity is nil or zero" do
+    line_item = LineItem.new(nil)
+
+    line_item.quantity = nil
+    line_item.unit_amount = BigDecimal("1.00")
+    line_item.tax_amount = BigDecimal("0.15")
+
+    assert_equal "0.0", line_item.line_amount.to_s, "expected line amount zero when quantity is nil"
+
+    line_item.quantity = 0
+    assert_equal "0.0", line_item.line_amount.to_s, "expected line amount zero when quantity is zero"
+  end
+
+  it "is not possible to set unit_amount to zero" do
+    line_item = LineItem.new(nil)
+
+    line_item.quantity = 1
+    line_item.unit_amount = nil
+    line_item.tax_amount = BigDecimal("0.15")
+
+    assert_equal 0.0, line_item.unit_amount,
+      "Expected setting unit_amount to nil to be ignored, i.e., it should remain zero"
+  end
+
+  it "line_amount is zero when unit_amount is nil or zero" do
+    line_item = LineItem.new(nil)
+
+    line_item.quantity = 1
+    line_item.unit_amount = nil
+    line_item.tax_amount = BigDecimal("0.15")
+
+    assert_equal "0.0", line_item.line_amount.to_s, "expected line amount zero when unit_amount is nil"
+
+    line_item.unit_amount = BigDecimal("0.00")
+    assert_equal "0.0", line_item.line_amount.to_s, "expected line amount zero when unit_amount is zero"
+  end
+end

data/test/unit/oauth_config_test.rb

@@ -0,0 +1,20 @@
+require "test_helper"
+
+class OAuthConfigTest < Test::Unit::TestCase
+  include Xeroizer
+
+  must "load oauth configuration from yaml" do
+    the_yaml = "
+    consumer:
+        key: key
+        secret: secret
+        key_file: key_file
+    "
+
+    result = OAuthConfig.load the_yaml
+
+    assert_equal "key",      result.consumer_key,    "Unexpected consumer_key value"
+    assert_equal "secret",   result.consumer_secret, "Unexpected consumer_secret value"
+    assert_equal "key_file", result.key_file,        "Unexpected key_file value"
+  end
+end

data/test/unit/oauth_test.rb

@@ -0,0 +1,97 @@
+require 'test_helper'
+
+class OAuthTest < Test::Unit::TestCase
+  include TestHelper
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+  end
+  
+  context "with oauth error handling" do
+    
+    should "handle token expired" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("token_expired"), :code => "401"))
+
+      assert_raises Xeroizer::OAuth::TokenExpired do
+        @client.Organisation.first
+      end
+    end
+    
+    should "handle invalid request tokens" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_request_token"), :code => "401"))
+      
+      assert_raises Xeroizer::OAuth::TokenInvalid do
+        @client.Organisation.first
+      end
+    end
+    
+    should "handle invalid consumer key" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("invalid_consumer_key"), :code => "401"))
+      
+      assert_raises Xeroizer::OAuth::TokenInvalid do
+        @client.Organisation.first
+      end
+    end
+      
+    should "raise rate limit exceeded" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("rate_limit_exceeded"), :code => "401"))
+      
+      assert_raises Xeroizer::OAuth::RateLimitExceeded do
+        @client.Organisation.first
+      end
+    end
+
+    should "automatically handle rate limit exceeded" do
+      auto_rate_limit_client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET, :rate_limit_sleep => 1)
+
+      # Return rate limit exceeded on first call, OK on the second
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(
+        stub(:plain_body => get_file_as_string("rate_limit_exceeded"), :code => "401"),
+        stub(:plain_body => get_record_xml(:organisation), :code => '200')
+      )
+
+      auto_rate_limit_client.expects(:sleep_for).with(1).returns(1)
+
+      auto_rate_limit_client.Organisation.first
+    end
+
+    should "only retry rate limited request a configurable number of times" do
+      auto_rate_limit_client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET, :rate_limit_sleep => 1, :rate_limit_max_attempts => 4)
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("rate_limit_exceeded"), :code => "401"))
+
+      auto_rate_limit_client.expects(:sleep_for).with(1).times(4).returns(1)
+
+      assert_raises Xeroizer::OAuth::RateLimitExceeded do
+        auto_rate_limit_client.Organisation.first
+      end
+    end
+      
+    should "handle unknown errors" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_file_as_string("bogus_oauth_error"), :code => "401"))
+      
+      assert_raises Xeroizer::OAuth::UnknownError do
+        @client.Organisation.first
+      end
+    end
+    
+    should "handle ApiExceptions" do
+      Xeroizer::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => get_file_as_string("api_exception.xml"), :code => "400"))
+      
+      assert_raises Xeroizer::ApiException do
+        contact = @client.Contact.build(:name => 'Test Contact')
+        contact.save
+      end
+    end
+    
+    should "handle random root elements" do
+      Xeroizer::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => "<RandomRootElement></RandomRootElement>", :code => "200"))
+      
+      assert_raises Xeroizer::UnparseableResponse do
+        contact = @client.Contact.build(:name => 'Test Contact')
+        contact.save
+      end      
+    end
+    
+  end
+  
+end

data/test/unit/private_application_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class PrivateApplicationTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PrivateApplication.new(CONSUMER_KEY, CONSUMER_SECRET, PRIVATE_KEY_PATH)
+  end
+  
+  context "initialization" do
+    
+    should "have a valid client" do
+      assert_kind_of(Xeroizer::OAuth, @client.client)
+      assert_equal(CONSUMER_KEY, @client.client.ctoken)
+      assert_equal(CONSUMER_SECRET, @client.client.csecret)
+    end
+    
+  end
+    
+end

data/test/unit/record/base_model_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class RecordBaseModelTest < Test::Unit::TestCase
+  include TestHelper
+  
+  class AppleModel < Xeroizer::Record::BaseModel
+    set_api_controller_name 'AppleController'
+    set_permissions :read, :write
+  end
+  
+  class PearModel < Xeroizer::Record::BaseModel
+    set_api_controller_name 'PearController'
+    set_permissions :read
+  end
+  
+  class OrangeModel < Xeroizer::Record::BaseModel
+    set_permissions :read, :write, :update
+  end
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @apple_model = AppleModel.new(@client, 'Apple')
+    @pear_model = PearModel.new(@client, 'Pear')
+    @orange_model = OrangeModel.new(@client, 'Orange')
+  end
+  
+  context "RecordModel.api_controller_name" do
+    
+    should "api_controller_name should default to pluralized model name" do
+      assert_equal('Oranges', @orange_model.api_controller_name)
+    end
+    
+    should "set_api_controller_name should set the base controller name used by Xero" do
+     assert_equal('AppleController', @apple_model.api_controller_name)
+     assert_equal('PearController', @pear_model.api_controller_name)
+    end
+    
+  end
+  
+  context "model permssions" do
+    
+    should "save permissions correctly" do
+      assert_equal(%w(read write), @apple_model.class.permissions.keys.map(&:to_s).sort)
+      assert_equal(%w(read), @pear_model.class.permissions.keys.map(&:to_s).sort)
+      assert_equal(%w(read update write), @orange_model.class.permissions.keys.map(&:to_s).sort)
+    end
+    
+  end
+
+end