xeroizer-float 2.15.3.1

data/test/unit/record/base_test.rb

@@ -0,0 +1,94 @@
+require 'test_helper'
+
+class RecordBaseTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @contact = @client.Contact.build(:name => 'Test Contact Name ABC')
+  end
+  
+  context "base record" do
+    
+    should "create new model instance from #new_model_class" do
+      model_class = @contact.new_model_class("Invoice")
+      assert_kind_of(Xeroizer::Record::InvoiceModel, model_class)
+      assert_equal(@contact.parent.application, model_class.application)
+      assert_equal('Invoice', model_class.model_name)
+    end
+    
+    should "new_record? should be new on create" do
+      assert_equal(true, @contact.new_record?)
+    end
+  
+  end
+  
+  context "new_record? states" do
+  
+    should "new_record? should be false when loading data" do
+      Xeroizer::OAuth.any_instance.stubs(:get).returns(stub(:plain_body => get_record_xml(:contact), :code => '200'))
+      contact = @client.Contact.find('TESTID')
+      assert_kind_of(Xeroizer::Record::Contact, contact)
+      assert_equal(false, contact.new_record?)
+    end
+    
+    should "new_record? should be false after successfully creating a record" do 
+      Xeroizer::OAuth.any_instance.stubs(:put).returns(stub(:plain_body => get_record_xml(:contact), :code => '200'))
+      assert_equal(true, @contact.new_record?)
+      assert_nil(@contact.contact_id)
+      assert_equal(true, @contact.save, "Error saving contact: #{@contact.errors.inspect}")
+      assert_equal(false, @contact.new_record?)
+      assert(@contact.contact_id =~ GUID_REGEX, "@contact.contact_id is not a GUID, it is '#{@contact.contact_id}'")
+    end
+    
+    should "new_record? should be false if we have specified a primary key" do
+      contact = @client.Contact.build(:contact_id => 'ABC')
+      assert_equal(false, contact.new_record?)
+      
+      contact = @client.Contact.build(:contact_number => 'CDE')
+      assert_equal(true, contact.new_record?)
+      
+      contact = @client.Contact.build(:name => 'TEST NAME')
+      assert_equal(true, contact.new_record?)
+    end
+    
+  end
+  
+  context "about logging" do
+    setup do
+      @example_class = Class.new(Xeroizer::Record::Base) do
+        def valid?; true; end
+        def to_xml(b = nil); "<FakeRequest />" end
+        string :id
+      end
+    end
+
+    must "log the request and response xml when saving a new record" do
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[CREATE SENT\]/}
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[CREATE RECEIVED\]/}
+
+      a_fake_parent = mock "Mock parent",
+        :http_put => "<FakeResponse />",
+        :parse_response => stub("Stub response", :response_items => [])
+
+      an_example_instance = @example_class.new(a_fake_parent)
+
+      an_example_instance.id = nil
+      an_example_instance.save
+    end
+
+    must "log the request and response xml when updating an existing record" do
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[UPDATE SENT\]/}
+      Xeroizer::Logging::Log.expects(:info).once.with {|arg| arg =~ /\[UPDATE RECEIVED\]/}
+
+      a_fake_parent = mock "Mock parent",
+        :http_post => "<FakeResponse />",
+        :parse_response => stub("Stub response", :response_items => [])
+
+      an_example_instance = @example_class.new(a_fake_parent)
+
+      an_example_instance.id = "phil's lunch box"
+      an_example_instance.save
+    end
+  end
+end

data/test/unit/record/block_validator_test.rb

@@ -0,0 +1,125 @@
+require "test_helper"
+
+class BlockValidatorTest < Test::Unit::TestCase
+  def setup
+    @fake_record_class = Class.new do
+      attr_accessor :errors
+      def initialize; @errors = []; end
+    end
+  end
+
+  it "returns valid when block returns true" do
+    record = @fake_record_class.new
+
+    the_block_returning_true = Proc.new{ true }
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      :block => the_block_returning_true
+    )
+
+    block_validator.valid?(record)
+
+    assert_empty record.errors, "Expected validation to pass. #{record.errors.inspect}"
+  end
+
+  it "returns invalid when block returns a non-null object" do
+    record = @fake_record_class.new
+
+    the_block_returning_true = Proc.new{ Object }
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      :block => the_block_returning_true
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size, "Expected validation to fail with one error. #{record.errors.inspect}"
+  end
+
+  it "returns invalid when block returns false" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size, "Expected validation to fail with one error. #{record.errors.inspect}"
+  end
+
+  it "uses the message supplied when validation fails" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    expected_error = "Cornrows are usually a headwear mistake"
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false,
+        :message => expected_error
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size,
+      "Expected validation to fail with one error. #{record.errors.inspect}"
+    assert_equal expected_error, record.errors.first[1],
+      "There is an error, but it doesn't match"
+  end
+
+  it "uses a default message when validation fails and no message has been supplied" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    expected_error = "block condition failed"
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size,
+      "Expected validation to fail with one error. #{record.errors.inspect}"
+    assert_equal expected_error, record.errors.first[1],
+      "There is an error, but it doesn't match"
+  end
+
+  it "uses a default message when validation fails and message has been supplied as empty" do
+    record = @fake_record_class.new
+
+    the_block_returning_false = Proc.new{ false }
+
+    expected_error = "block condition failed"
+
+    block_validator = Xeroizer::Record::Validator::BlockValidator.new(
+      :name,
+      {
+        :block => the_block_returning_false,
+        :message => ""
+      }
+    )
+
+    block_validator.valid?(record)
+
+    assert_equal 1, record.errors.size,
+      "Expected validation to fail with one error. #{record.errors.inspect}"
+    assert_equal expected_error, record.errors.first[1],
+      "There is an error, but it doesn't match"
+  end
+end

data/test/unit/record/model_definition_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class ModelDefinitionsTest < Test::Unit::TestCase
+  include TestHelper
+  
+  class FirstRecord < Xeroizer::Record::Base
+    
+    set_primary_key :primary_key_id
+    
+    guid      :primary_key_id
+    string    :string1
+    boolean   :boolean1
+    integer   :integer1
+    decimal   :decimal1
+    date      :date1
+    datetime  :datetime1
+    
+  end
+  
+  class SecondRecord < Xeroizer::Record::Base
+
+    set_primary_key :primary_key_id
+    
+    guid      :primary_key_id
+    string    :string2
+    boolean   :boolean2
+    integer   :integer2
+    decimal   :decimal2
+    date      :date2
+    datetime  :datetime2
+
+  end
+    
+  class TestRecord < Xeroizer::Record::Base
+    
+    string    :xml_name, :api_name => 'ApiNameHere', :internal_name => :internal_name_here
+    string    :name
+    
+  end
+  
+  class SummaryOnlyRecord < Xeroizer::Record::Base
+    
+    list_contains_summary_only true
+    set_possible_primary_keys :primary_key_id
+    set_primary_key :primary_key_id
+    
+    string :primary_key_id
+    string :name
+  end
+  
+  class SummaryOnlyOffRecord < Xeroizer::Record::Base
+    
+    set_possible_primary_keys :primary_key_id
+    set_primary_key :primary_key_id
+    
+    string :primary_key_id
+    string :name
+  end
+  
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @first = FirstRecord.new(@client)
+    @second = SecondRecord.new(@client)
+    @record = TestRecord.build({}, @client.Contact)
+    @contact = @client.Contact.build
+  end
+  
+  context "list contains summary only test" do
+    
+    should "show download complete if not summary record and id set" do
+      record = SummaryOnlyRecord.build({}, @client.Contact)
+      record.id = "NOTBLANK"
+      assert_equal(false, record.new_record?)
+      assert_equal(false, record.complete_record_downloaded?)
+      
+      record = SummaryOnlyOffRecord.build({}, @client.Contact)
+      record.id = "NOTBLANK"
+      assert_equal(false, record.new_record?)
+      assert_equal(true, record.complete_record_downloaded?)
+    end
+    
+  end
+  
+  context "record field definition" do
+    
+    should "define primary key with real name" do
+      assert_nil(@first.id)
+      value = "PRIMARY KEY VALUE"
+      @first.primary_key_id = value
+      assert_equal(value, @first.primary_key_id)
+      assert_equal(value, @first.id)
+    end
+    
+    should "define primary key with shortcut #id method" do
+      assert_nil(@first.id)
+      value = "PRIMARKY KEY VALUE"
+      @first.id = value
+      assert_equal(value, @first.id)
+      assert_equal(value, @first.primary_key_id)
+    end
+    
+    should "only have proper fields" do
+      fieldset = [:primary_key_id, :string1, :boolean1, :integer1, :decimal1, :date1, :datetime1]
+      fieldset.each do | field |
+        assert(@first.class.fields.keys.include?(field), "#{field} not in FirstRecord.fields")
+      end
+      assert_equal(fieldset.size, @first.class.fields.size)
+
+      fieldset = [:primary_key_id, :string2, :boolean2, :integer2, :decimal2, :date2, :datetime2]
+      fieldset.each do | field |
+        assert(@second.class.fields.keys.include?(field), "#{field} not in SecondRecord.fields")
+      end
+      assert_equal(fieldset.size, @second.class.fields.size)        
+    end
+    
+    should "have correct names" do
+      assert(@record.respond_to?(:internal_name_here), "Internal name should be internal_name_here")
+      assert(@record.class.fields.keys.include?(:xml_name), "Field key name should be xml_name")
+      assert_equal('ApiNameHere', @record.class.fields[:xml_name][:api_name])
+    end
+    
+    should "have shortcut reader/writer" do 
+      assert_nil(@first.string1)
+      value = 'TEST VALUE'
+      @first.string1 = value
+      assert_equal(value, @first.attributes[:string1])
+      assert_equal(value, @first[:string1])
+
+      value = 'TEST VALUE 2'
+      @first[:string1] = value
+      assert_equal(value, @first.attributes[:string1])
+    end
+        
+    should "define reader/writer methods" do
+      assert(@record.respond_to?(:name), "FirstRecord#name should exist.")
+      assert(@record.respond_to?(:name=), "FirstRecord#name= should exist.")
+      
+      value = "TEST NAME"
+      @record.attributes[:name] = value
+      assert_equal(value, @record.attributes[:name])
+      assert_equal(value, @record[:name])
+      assert_equal(value, @record.name)
+      
+      value = "TEST DIFFERENT"
+      @record.name = value
+      assert_equal(value, @record.attributes[:name])
+      assert_equal(value, @record[:name])
+      assert_equal(value, @record.name)
+      
+      value = "TEST DIFFERENT AGAIN"
+      @record[:name] = value
+      assert_equal(value, @record.attributes[:name])
+      assert_equal(value, @record[:name])
+      assert_equal(value, @record.name)
+    end
+    
+  end
+  
+end

data/test/unit/record/parse_where_hash_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module Xeroizer
+  module Record
+    
+    class WhereHashTestModel < BaseModel
+    end
+    
+    class WhereHashTest < Base
+
+      set_primary_key :primary_key_id
+
+      guid      :primary_key_id
+      string    :string1
+      boolean   :boolean1
+      integer   :integer1
+      decimal   :decimal1
+      date      :date1
+      datetime  :datetime1
+
+    end
+  
+  end
+end  
+
+class ParseWhereHashTest < Test::Unit::TestCase
+  include TestHelper
+    
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    @model = Xeroizer::Record::WhereHashTestModel.new(@client, "WhereHashTest")
+  end
+  
+  context "where hash" do
+    
+    should "parse valid hash" do
+      @model.send(:parse_where_hash, {
+        :primary_key_id => 'f7eca431-5c97-4d24-93fd-004bb8a6c644', 
+        :string1 => 'test', 
+        :boolean1 => true, 
+        :integer1 => 10,
+        :decimal1 => 123.45,
+        :date1 => Date.parse("2010-01-05"),
+        :datetime1 => Time.parse("2010-02-30 09:10:20")
+      })
+    end
+    
+    should 'have valid expression components' do
+      assert_equal('String1=="abc"', CGI.unescape(@model.send(:parse_where_hash, {:string1 => 'abc'})))
+      assert_equal('String1<>"abc"', CGI.unescape(@model.send(:parse_where_hash, {:string1_is_not => 'abc'})))
+      assert_equal('String1<>"abc"', CGI.unescape(@model.send(:parse_where_hash, {:"string1<>" => 'abc'})))
+      assert_equal('String1>"abc"', CGI.unescape(@model.send(:parse_where_hash, {:string1_is_greater_than => 'abc'})))
+      assert_equal('String1>"abc"', CGI.unescape(@model.send(:parse_where_hash, {:"string1>" => 'abc'})))
+      assert_equal('String1>="abc"', CGI.unescape(@model.send(:parse_where_hash, {:string1_is_greater_than_or_equal_to => 'abc'})))
+      assert_equal('String1>="abc"', CGI.unescape(@model.send(:parse_where_hash, {:"string1>=" => 'abc'})))
+      assert_equal('String1<"abc"', CGI.unescape(@model.send(:parse_where_hash, {:string1_is_less_than => 'abc'})))
+      assert_equal('String1<"abc"', CGI.unescape(@model.send(:parse_where_hash, {:"string1<" => 'abc'})))
+      assert_equal('String1<="abc"', CGI.unescape(@model.send(:parse_where_hash, {:string1_is_less_than_or_equal_to => 'abc'})))
+      assert_equal('String1<="abc"', CGI.unescape(@model.send(:parse_where_hash, {:"string1<=" => 'abc'})))
+    end
+  end
+
+end

data/test/unit/record/record_association_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class RecordAssociationTest < Test::Unit::TestCase
+  include TestHelper
+
+  def setup
+    @client = Xeroizer::PublicApplication.new(CONSUMER_KEY, CONSUMER_SECRET)
+    mock_api('Invoices')
+    @client.stubs(:http_put).returns(get_record_xml(:invoice, "762aa45d-4632-45b5-8087-b4f47690665e"))
+  end
+  
+  context "belongs_to association" do
+    
+    should "auto-load complete record if summary" do
+      invoice = @client.Invoice.first
+      assert_nil(invoice.attributes[:contact].contact_status)
+      assert_equal(false, invoice.complete_record_downloaded?)
+      assert_not_nil(invoice.contact.contact_status)
+      assert_equal(true, invoice.complete_record_downloaded?)
+    end
+    
+  end
+  
+  context "has_many association" do
+    
+    should "auto-load complete records if summary" do
+      invoice = @client.Invoice.first
+      assert_nil(invoice.attributes[:line_items])
+      assert_equal(false, invoice.complete_record_downloaded?)
+      assert(invoice.line_items.size > 0, "There should be one or more line items.")
+      assert_equal(true, invoice.complete_record_downloaded?)
+    end
+    
+    should "auto-build belongs_to item when passed hash" do
+      invoice = @client.Invoice.build
+      assert_nil(invoice.contact)
+      invoice.contact = {:name => "Test Contact"}
+      assert_kind_of(Xeroizer::Record::Contact, invoice.contact)
+      assert_equal("Test Contact", invoice.contact.name)
+    end
+    
+    should "auto-build has_many items when passed hash" do
+      contact = @client.Contact.build
+      assert_equal([], contact.phones)
+      contact.phones = {:type => "DEFAULT", :number => "1234"}
+      assert_kind_of(Xeroizer::Record::Phone, contact.phones.first)
+      assert_equal("1234", contact.phones.first.number)
+    end
+    
+    should "auto-build has_many items when passed array" do
+      contact = @client.Contact.build
+      assert_equal([], contact.phones)
+      
+      data = [
+        {:type => "DEFAULT", :number => "1111"},
+        {:type => "FAX", :number => "2222"}
+      ]
+      contact.phones = data.dup
+
+      assert_equal(2, contact.phones.size)
+      contact.phones.each_with_index do | phone, index | 
+        assert_kind_of(Xeroizer::Record::Phone, phone)
+        assert_equal(data[index][:number], phone.number)
+      end
+    end
+    
+    should "retain unsaved items after create" do
+      invoice = @client.Invoice.build :type => "ACCREC", :contact => { :name => "A" }
+      invoice.save
+      invoice.add_line_item :description => "1"
+      assert_equal(1, invoice.line_items.size, "There should be one line item.")
+    end
+
+    should "retain unsaved items after find" do
+      invoice = @client.Invoice.find "762aa45d-4632-45b5-8087-b4f47690665e"
+      invoice.add_line_item :description => "1"
+      assert_equal(1, invoice.line_items.size, "There should be one line item.")
+    end
+
+    should "retain unsaved items after summary find" do
+      invoice = @client.Invoice.all.last
+      invoice.add_line_item :description => "1"
+      assert_equal(1, invoice.line_items.size, "There should be one line item.")
+    end
+
+    should "retain unsaved items when set explicitly" do
+      invoice = @client.Invoice.all.last
+      invoice.line_items = [{ :description => "1" }]
+      assert_equal(1, invoice.line_items.size, "There should be one line item.")
+    end
+  end
+  
+end