xeroizer 0.3.5 → 0.4.0

data/lib/xeroizer/record/validation_helper.rb

@@ -14,6 +14,7 @@ module Xeroizer
         # Adds a validator config for each attribute specified in args.
         def validates_with_validator(validator, args)
           options = args.extract_options!
+          
           self.validators ||= []
           args.flatten.each do | attribute |
             self.validators << validator.new(attribute, options)
@@ -31,7 +32,18 @@ module Xeroizer
         def validates_presence_of(*args)
           validates_with_validator(Validator::PresenceOfValidator, args)
         end        
-        
+     
+        def validates(*args, &block)
+          fail "Block required" unless block_given?
+
+          if args.last.is_a? Hash
+            args.last[:block] = block
+          else
+            args << { :block => block }
+          end
+
+          validates_with_validator(Validator::BlockValidator, args)
+        end
       end
       
       module InstanceMethods
@@ -56,4 +68,4 @@ module Xeroizer
       
     end
   end
-end
+end

data/lib/xeroizer/record/validators/block_validator.rb

@@ -0,0 +1,22 @@
+module Xeroizer
+  module Record
+    class Validator
+      class BlockValidator < Validator
+        def valid?(record)
+          fail "No block provided" unless options[:block]
+          
+          result = record.instance_eval &options[:block]
+          
+          record.errors << [attribute, message] unless result == true
+        end
+
+        private
+        
+        def message
+          supplied_message = options[:message] || ""
+          supplied_message.empty? ? "block condition failed" : supplied_message
+        end
+      end
+    end
+  end
+end

data/lib/xeroizer/record/validators/validator.rb

@@ -12,12 +12,21 @@ module Xeroizer
       end
   
       def validate(record)
-        run_validator = true
-        run_validator = false if options[:if] && !options[:if].call(record)
-        run_validator = false if options[:unless] && options[:unless].call(record)
-        valid?(record) if run_validator
+        valid?(record) if run_validator?(record, options)
       end
-  
+
+      def run_validator?(record, options)
+        return false if options[:if] && !condition?(record, options[:if])
+        return false if options[:unless] && condition?(record, options[:unless])
+        true
+      end
+
+      def condition?(record, condition)
+        return condition.call(record) if condition.respond_to? :call
+        return record.send(condition) if condition.is_a? Symbol
+        raise "Validation condition must be a Symbol or an Object that responds to call"
+      end
+
     end
     
   end

data/lib/xeroizer/record/xml_helper.rb

@@ -56,17 +56,34 @@ module Xeroizer
         
           # Turn a record into its XML representation.
           def to_xml(b = Builder::XmlMarkup.new(:indent => 2))
-            b.tag!(parent.class.xml_node_name || parent.model_name) { 
-              attributes.each do | key, value |
-                field = self.class.fields[key]
-                value = self.send(key) if field[:calculated]
-                xml_value_from_field(b, field, value) unless value.nil?
-              end
-            }
+            optional_root_tag(parent.class.xml_root_name, b) do |b|
+              b.tag!(parent.class.xml_node_name || parent.model_name) { 
+                attributes.each do | key, value |
+                  field = self.class.fields[key]
+                  value = self.send(key) if field[:calculated]
+                  xml_value_from_field(b, field, value) unless value.nil?
+                end
+              }
+            end
           end
           
         protected
         
+          # Add top-level root name if required.
+          # E.g. Payments need specifying in the form:
+          #   <Payments>
+          #     <Payment>
+          #       ...
+          #     </Payment>
+          #   </Payments>
+          def optional_root_tag(root_name, b, &block)
+            if root_name
+              b.tag!(root_name) { |b| yield(b) }
+            else
+              yield(b)
+            end
+          end
+        
           # Format a attribute for use in the XML passed to Xero.
           def xml_value_from_field(b, field, value)
             case field[:type]

data/test/acceptance/about_creating_bank_transactions_test.rb

@@ -0,0 +1,162 @@
+require "test_helper"
+require "acceptance_test"
+
+class AboutCreatingBankTransactions < Test::Unit::TestCase
+  include AcceptanceTest
+
+  let :client do
+    Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  end
+
+  def setup
+    super
+    all_accounts = client.Account.all
+    @account = all_accounts.select{|account| account.status == "ACTIVE" && account.type == "REVENUE"}.first
+    @bank_account = all_accounts.select{|account| account.status == "ACTIVE" && account.type == "BANK"}.first
+  end
+
+  can "create a new SPEND bank transaction" do
+    new_transaction = client.BankTransaction.build(
+      :type => "SPEND",
+      :contact => { :name => "Jazz Kang" },
+      :line_items => any_line_items(@account),
+      :bank_account => { :code => @bank_account.code }
+    )
+
+    assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
+    assert_exists new_transaction
+  end
+
+  can "update a SPEND bank transaction, for example by setting its status" do
+    new_transaction = client.BankTransaction.build(
+      :type => "SPEND",
+      :contact => { :name => "Jazz Kang" },
+      :line_items => any_line_items(@account),
+      :bank_account => { :code => @bank_account.code }
+    )
+
+    assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
+
+    assert_exists new_transaction
+
+    the_new_type = "RECEIVE"
+
+    expected_id = new_transaction.id
+
+    new_transaction.type = the_new_type
+
+    assert new_transaction.save, "Update failed with the following errors: #{new_transaction.errors.inspect}"
+
+    assert_equal expected_id, new_transaction.id, "Expected the id to be the same because it has been updated"
+
+    refreshed_bank_transaction = client.BankTransaction.find expected_id
+
+    assert_equal the_new_type, refreshed_bank_transaction.type,
+      "Expected the bank transaction to've had its type updated"
+  end
+
+  can "update a bank transaction by adding line items provided you calculate the tax_amount correctly" do
+    new_transaction = client.BankTransaction.build(
+      :type => "SPEND",
+      :contact => { :name => "Jazz Kang" },
+      :line_items => any_line_items(@account),
+      :bank_account => { :code => @bank_account.code },
+      :line_amount_types => "Exclusive"
+    )
+
+    assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
+    assert_exists new_transaction
+
+    expected_id = new_transaction.id
+
+    tax_rate = get_tax_rate(@account.tax_type).effective_rate
+
+    unit_price = BigDecimal("1337.00")
+
+    the_new_line_items = [
+      {
+        :description => "Burrito skin",
+        :quantity => 1,
+        :unit_amount => unit_price,
+        :account_code => @account.code,
+        :tax_type => @account.tax_type,
+        :tax_amount => get_exclusive_tax(unit_price, tax_rate)
+      }
+    ]
+
+    new_transaction.line_items = the_new_line_items
+
+    assert new_transaction.save, "Update failed with the following errors: #{new_transaction.errors.inspect}"
+
+    refreshed_bank_transaction = client.BankTransaction.find expected_id
+
+    assert_equal expected_id, new_transaction.id,
+      "Expected the id to be the same because it has been updated"
+
+    assert_equal 1, refreshed_bank_transaction.line_items.size,
+      "Expected the bank transaction to've had its line items updated to just one"
+
+    the_first_line_item = refreshed_bank_transaction.line_items.first
+
+    assert_equal "Burrito skin", the_first_line_item.description,
+      "Expected the bank transaction to've had its line items updated, " +
+      "but the first one's description does not match: #{the_first_line_item.inspect}"
+  end
+
+  def get_inclusive_tax(amount, tax_rate)
+    inclusive_tax = amount * (1 - (100/(100 + tax_rate)))
+    BigDecimal(inclusive_tax.to_s).round(2)
+  end
+
+  def get_exclusive_tax(amount, tax_rate)
+    exclusive_tax = amount * (tax_rate/100)
+    BigDecimal(exclusive_tax.to_s).round(2)
+  end
+
+  def get_tax_rate tax_type
+    @all_tax_types ||= client.TaxRate.all
+    @all_tax_types.select{|tax_rate| tax_rate.tax_type == tax_type}.first
+  end
+
+  can "create a new RECEIVE bank transaction" do
+    new_transaction = client.BankTransaction.build(
+      :type => "RECEIVE",
+      :contact => { :name => "Jazz Kang" },
+      :line_items => any_line_items(@account),
+      :bank_account => { :code => @bank_account.code }
+    )
+
+    assert new_transaction.save, "Save failed with the following errors: #{new_transaction.errors.inspect}"
+    assert_exists new_transaction
+  end
+
+  it "treats line item unit_amounts as tax EXCLUSIVE"
+  must "not set the tax_amount manually on line items"
+
+  def assert_exists(bank_transaction)
+    assert_not_nil bank_transaction.id,
+      "Cannot check for exitence unless the bank transaction has non-null identifier"
+    assert_not_nil client.BankTransaction.find bank_transaction.id
+  end
+
+  def any_line_items(account)
+    [{
+      :description => "Clingfilm bike shorts",
+      :quantity => 1,
+      :unit_amount => "17.00",
+      :account_code => account.code,
+      :tax_type => account.tax_type
+    }]
+  end
+
+  it "fails with RuntimeError when you try and create a new bank account" do
+    new_account = client.Account.build(
+      :name => "Example bank account",
+      :code => "ACC-001"
+    )
+
+    assert_raise RuntimeError do
+      new_account.save
+    end
+  end
+end

data/test/acceptance/about_fetching_bank_transactions_test.rb

@@ -0,0 +1,56 @@
+require "test_helper"
+require "acceptance_test"
+require "bank_transaction_reference_data"
+
+class AboutFetchingBankTransactions < Test::Unit::TestCase
+  include AcceptanceTest
+
+  def client
+    @client ||= Xeroizer::PrivateApplication.new(@consumer_key, @consumer_secret, @key_file)
+  end
+
+  context "when requesting all bank transactions (i.e., without filter)" do
+    setup do
+      @the_first_bank_transaction = client.BankTransaction.all.first
+    end
+
+    it "returns line items empty" do
+      assert_empty(@the_first_bank_transaction.line_items, "Expected line items to've been excluded")
+    end
+
+    it "returns contact with name and and id ONLY (no addresses or phones)" do
+      the_contact = @the_first_bank_transaction.contact
+      assert_not_nil(the_contact.contact_id, "Expected contact id to be present")
+      assert_not_nil(the_contact.name, "Expected contact name to be present")
+      assert_empty the_contact.phones, "Expected empty contact phones"
+      assert_empty the_contact.addresses, "Expected empty contact addresses"
+    end
+
+    it "returns the bank account" do
+      assert_not_nil @the_first_bank_transaction.bank_account
+    end
+  end
+
+  context "when requesting a single bank transaction for example" do
+    setup do
+      @a_new_bank_transaction = BankTransactionReferenceData.new(client).bank_transaction
+    end
+
+    it "returns contact with addresses and phones" do
+      single_bank_transaction = client.BankTransaction.find @a_new_bank_transaction.id
+
+      assert_not_empty single_bank_transaction.contact.addresses,
+        "expected the contact's addresses to have been included"
+
+      assert_not_empty single_bank_transaction.contact.phones,
+        "expected the contact's phone numbers to have been included"
+    end
+
+    it "returns full line item details" do
+      single_bank_transaction = client.BankTransaction.find @a_new_bank_transaction.id
+
+      assert_not_empty single_bank_transaction.line_items,
+        "expected the bank transaction's line items to have been included"
+    end
+  end
+end

data/test/acceptance/acceptance_test.rb

@@ -0,0 +1,53 @@
+module AcceptanceTest
+  class << self
+    def included(klass)
+      klass.class_eval do
+        def self.log_to_console
+          Xeroizer::Logging.const_set :Log, Xeroizer::Logging::StdOutLog
+        end
+
+        def self.no_log
+          Xeroizer::Logging.const_set :Log, Xeroizer::Logging::DevNullLog
+        end
+
+        def self.let(symbol, &block)
+          return unless block_given?
+
+          unless respond_to? symbol
+            define_method symbol, do
+              cached_method_result = instance_variable_get ivar_name = "@#{symbol}"
+              instance_variable_set(ivar_name, instance_eval(&block)) if cached_method_result.nil?
+              instance_variable_get ivar_name
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def setup
+    config = load_config_from_file || load_config_from_env
+
+    @key_file = config.key_file
+    @consumer_key = config.consumer_key
+    @consumer_secret = config.consumer_secret
+  end
+
+  private
+
+  def load_config_from_file
+    the_file_name = ".oauth"
+
+    return nil unless File.exists? the_file_name
+
+    Xeroizer::OAuthConfig.load IO.read the_file_name
+  end
+
+  def load_config_from_env
+    assert_not_nil ENV["CONSUMER_KEY"], "No CONSUMER_KEY environment variable specified."
+    assert_not_nil ENV["CONSUMER_SECRET"], "No CONSUMER_SECRET environment variable specified."
+    assert_not_nil ENV["KEY_FILE"], "No KEY_FILE environment variable specified."
+    assert File.exists?(ENV["KEY_FILE"]), "The file <#{ENV["KEY_FILE"]}> does not exist."
+    OAuthCredentials.new ENV["CONSUMER_KEY"], ENV["CONSUMER_SECRET"], ENV["KEY_FILE"]
+  end
+end

data/test/acceptance/bank_transaction_reference_data.rb

@@ -0,0 +1,31 @@
+class BankTransactionReferenceData
+  def initialize(client); @client = client; end
+  def bank_transaction; @bank_transaction ||= new_bank_transaction; end
+
+  private
+
+  def new_bank_transaction
+    all_accounts = @client.Account.all
+
+    account = all_accounts.select{|account| account.status == "ACTIVE" && account.type == "REVENUE"}.first
+    bank_account = all_accounts.select{|account| account.status == "ACTIVE" && account.type == "BANK"}.first
+
+    result = @client.BankTransaction.build(
+      :type => "SPEND",
+      :contact => { :name => "Jazz Kang" },
+      :line_items => [
+        :item_code => "Clingfilm bike shorts",
+        :description => "Bike shorts made of clear, unbreathable material",
+        :quantity => 1,
+        :unit_amount => 39.99,
+        :account_code => account.code,
+        :tax_type => account.tax_type
+      ],
+      :bank_account => { :code => bank_account.code }
+    )
+
+    fail("Expected save to have succeeded, but it failed. #{result.errors.inspect}") unless result.save
+
+    result
+  end
+end

data/test/test_helper.rb

@@ -7,9 +7,11 @@ require 'pp'
 
 require File.dirname(__FILE__) + '/../lib/xeroizer.rb'
 
+$: << File.join(File.dirname(__FILE__), "acceptance") 
+
 module TestHelper
 
-  # The integration tests can be run against the Xero test environment.  You mush have a company set up in the test
+  # The integration tests can be run against the Xero test environment.  You must have a company set up in the test
   # environment, and you must have set up a customer key for that account.
   #
   # You can then run the tests against the test environment using the commands (linux or mac):
@@ -55,3 +57,11 @@ module TestHelper
   end
     
 end
+
+Shoulda::ClassMethods.class_eval do
+  %w{it must can}.each do |m|
+    alias_method m, :should
+  end
+  
+  alias_method :must_eventually, :should_eventually
+end