caruby-core 1.4.4 → 1.4.5

data/test/lib/caruby/util/command_test.rb

@@ -0,0 +1,55 @@
+$:.unshift 'lib'
+
+require "test/unit"
+
+require 'caruby/cli/command'
+require 'set'
+
+module CaRuby
+  class CommandTest < Test::Unit::TestCase
+    def test_empty
+      verify_execution(Command.new, "test", {})
+    end
+    
+    def test_args_only
+      verify_execution(Command.new(:arg), "test arg", :arg => 'arg')
+    end
+    
+    def test_nonmandatory_argument_option
+      verify_execution(Command.new(:opt => :none), "test --opt", :opt => true)
+    end
+    
+    def test_mandatory_argument_option
+      verify_execution(Command.new(:opt => :mandatory), "test --opt opt", {:opt => 'opt'})
+    end
+    
+    def test_integer_argument_option
+      verify_execution(Command.new(:opt => :integer), "test --opt 1", {:opt => 1})
+    end
+    
+    def test_array_argument_option
+      verify_execution(Command.new(:opt => :array), "test --opt a,b", {:opt => ['a', 'b']})
+    end
+    
+    def test_complex
+      verify_execution(Command.new(:arg1, :opt1 => :none, :opt2 => :optional, :opt3 => :mandatory),
+        "test --opt1 --opt3 opt3 arg1 arg2",
+        {:opt1 => true, :opt3 => 'opt3', :arg1 => 'arg1'},
+        'arg2')
+    end
+    
+    private
+    
+    def verify_execution(cmd, s, opts, *args)
+      ARGV.clear.concat(s.split[1..-1])
+      cmd.start do |copts, *cargs|
+        opts.each do |opt, expected|
+          actual = copts[opt]
+          assert_not_nil(actual, "Command option #{opt} not found.")
+          assert_equal(expected, actual, "Command option #{opt} parsed incorrectly.")
+        end
+        assert_equal(cargs, args, "Command arguments differ.")
+      end
+    end
+  end
+end

data/test/lib/caruby/util/controlled_value_test.rb

@@ -0,0 +1,26 @@
+$:.unshift 'lib'
+
+require "test/unit"
+
+require 'caruby/util/controlled_value'
+require 'set'
+
+class ControlledValueTest < Test::Unit::TestCase
+  def setup
+    @parent = CaRuby::ControlledValue.new('parent')
+    @c1 = CaRuby::ControlledValue.new('c1', @parent)
+    @gc11 = CaRuby::ControlledValue.new('gc11', @c1)
+    @gc12 = CaRuby::ControlledValue.new('gc12', @c2)
+    @c2 = CaRuby::ControlledValue.new('c2', @parent)
+    @gc21 = CaRuby::ControlledValue.new('gc21', @c2)
+  end
+
+  def test_parent
+    assert_same(@c1, @gc11.parent, "Parent incorrect")
+    assert(@c1.children.include?(@gc11), "Children incorrect")
+  end
+
+  def test_descendants
+    assert(@parent.descendants.include?(@gc21), "Descendants incorrect")
+  end
+end

data/test/lib/caruby/util/domain_extent_test.rb

@@ -0,0 +1,60 @@
+$:.unshift 'lib'
+
+require "test/unit"
+
+require 'caruby/util/domain_extent'
+
+class DomainExtentTest < Test::Unit::TestCase
+  # Test composite key class
+  class Composite
+    attr_reader :a, :b, :c
+
+    def initialize(a, b, c=3)
+      super()
+      @a = a; @b = b; @c = c
+    end
+
+    def ==(other)
+      a == other.a && b == other.b && c == other.c
+    end
+  end
+
+  attr_reader :extent
+
+  def setup
+    @extent = DomainExtent.new
+  end
+
+  def test_create_on_demand
+    assert(!extent.has_key?(String), 'New domain extent not empty')
+    assert_not_nil(extent[String], 'Entry not created on demand')
+  end
+
+  def test_existing_fetch
+    expected = extent[String][1] = 'a'
+    target = extent.get(String, 1)
+    assert_equal(expected, target, 'Existing entry not found')
+  end
+
+  def test_missing_fetch
+    assert_nil(DomainExtent.new.get(Symbol, :a), 'Default factory instance not nil')
+  end
+
+  def test_simple_key_factory
+    extent = DomainExtent.new
+    # the String extent key is a number
+    # the String extent value is the number as a string
+    extent.set_factory(String) { |key| key.to_s }
+    assert_equal('1', extent.get(String, 1), 'Simple key instance not found')
+  end
+
+  def test_composite_key_factory
+    extent = DomainExtent.new
+    # the String extent key is a number
+    # the String extent value is the number as a string
+    extent.set_factory(Composite) { |key| Composite.new(key[:a], key[:b], key[:c]) }
+    key = {:a => 1, :b => 2, :c => 3}
+    expected = Composite.new(1, 2, 3)
+    assert_equal(expected, extent.get(Composite, key), 'Composite key instance not found')
+  end
+end

data/test/lib/caruby/util/file_separator_test.rb

@@ -0,0 +1,30 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/file_separator'
+
+class FileSeparatorTest < Test::Unit::TestCase
+  FIXTURES_DIR = 'test/fixtures/caruby/util'
+  LF_FILE = File.join(FIXTURES_DIR, 'lf_line_sep.txt')
+  CR_FILE = File.join(FIXTURES_DIR, 'cr_line_sep.txt')
+  CRLF_FILE = File.join(FIXTURES_DIR, 'crlf_line_sep.txt')
+
+  def test_lf_line_separator
+    verify_read(LF_FILE, "LF")
+  end
+
+  def test_cr_line_separator
+    verify_read(CR_FILE, "CR")
+  end
+
+  def test_crlf_line_separator
+    verify_read(CRLF_FILE, "CRLF")
+  end
+
+  def verify_read(file, type)
+    lines = File.open(file) { |io| io.readlines }
+    assert_equal(3, lines.size, "#{type} line separator not recognized in readlines")
+    lines = File.open(file) { |io| io.to_a }
+    assert_equal(3, lines.size, "#{type} line separator not recognized in to_a")
+  end
+end

data/test/lib/caruby/util/inflector_test.rb

@@ -0,0 +1,12 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/inflector'
+
+class InflectorTest < Test::Unit::TestCase
+   def test_quantified_s
+    assert_equal("1 person", "person".quantify(1))
+    assert_equal("2 people", "person".quantify(2))
+    assert_equal("0 people", "person".quantify(0))
+  end
+end

data/test/lib/caruby/util/lazy_hash_test.rb

@@ -0,0 +1,34 @@
+$:.unshift 'lib'
+
+require "test/unit"
+
+require 'caruby/util/domain_extent'
+
+class LazyHastTest < Test::Unit::TestCase
+
+  def test_value_factory
+    hash = LazyHash.new { |key| key.to_s }
+    assert_equal('1', hash[1], "Factory return value is incorrect")
+  end
+
+  def test_default_value_factory
+    hash = LazyHash.new
+    assert_nil(hash[1], "Default factory does not return")
+    assert(hash.has_key?(1), "Default entry not created")
+  end
+
+  def test_nil_key
+    hash = LazyHash.new
+    assert_nil(hash[nil], "nil key does not return")
+    assert(!hash.has_key?(nil), "Entry created for nil key")
+  end
+
+  def test_reject_missing_value
+    hash = LazyHash.new(:compact => true)
+    assert(!hash.has_key?(1), "Default entry created for nil value")
+  end
+
+  def test_fetch
+    assert_raises(IndexError, "Fetch non-existent doesn't raise IndexError") { LazyHash.new.fetch(:a) }
+  end
+end

data/test/lib/caruby/util/merge_test.rb

@@ -0,0 +1,83 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/merge'
+require 'caruby/util/log'
+
+class MergeTest < Test::Unit::TestCase
+  LogCaRuby::Log.instance.open(File.join('test', 'results', 'log', 'caruby.log'), :debug => true)
+
+  class Target
+    include Mergeable
+
+    attr_accessor :a, :b, :c, :array
+
+    def self.mergeable_attributes
+      [:a, :b]
+    end
+  end
+
+  class Partial
+    attr_accessor :a, :c, :d
+  end
+
+  attr_reader :target
+
+  def setup
+    @target = Target.new
+  end
+
+  def test_merge_attributes_hash
+    target.merge_attributes(:a => 1, :b => 2, :c => 3)
+    assert_equal(1, target.a, 'Attribute not merged')
+    assert_equal(2, target.b, 'Attribute not merged')
+    assert_equal(3, target.c, 'Attribute not merged')
+  end
+
+  def test_merge_attributes_other
+    other = Target.new
+    other.a = 1
+    other.b = 2
+    other.c = 3
+    target.merge_attributes(other)
+    assert_equal(1, target.a, 'Attribute not merged')
+    assert_equal(2, target.b, 'Attribute not merged')
+    assert_nil(target.c, 'Non-mergeable attribute merged')
+  end
+
+  def test_merge_attributes_other_partial
+    other = Partial.new
+    other.a = 1
+    other.c = 3
+    other.d = 4
+    target.merge_attributes(other)
+    assert_equal(1, target.a, 'Attribute not merged')
+    assert_nil(target.c, 'Non-mergeable attribute merged')
+  end
+
+  def test_array_merge
+    array = [1]
+    array.merge([1, 2])
+    assert_equal([1, 2], array, 'Array deep merge incorrect')
+  end
+
+  def test_array_attribute_merge
+    target.a = [1]
+    target.merge_attributes(:array => [1, 2])
+    assert_equal([1, 2], target.array, 'Array attribute not merged correctly')
+  end
+
+  def test_hash_deep_merge
+    assert_equal({:a => [1], :b => [2, 3]}, {:a => [1], :b => [2]}.merge({:b => [3]}, :deep), 'Hash deep merge incorrect')
+  end
+
+  def test_hash_in_place_deep_merge
+    hash = {:a => [1], :b => [2]}
+    hash.merge!({:b => [3], :c => 4}, :deep)
+    assert_equal({:a => [1], :b => [2, 3], :c => 4}, hash, 'Hash deep merge incorrect')
+  end
+
+  def test_nested_hash_deep_merge
+    assert_equal({:a => {:b => [1, 2]}, :c => 3}, {:a => {:b => [1]}}.merge({:a => {:b => [2]}, :c => 3}, :deep), 'Hash deep merge incorrect')
+  end
+end

data/test/lib/caruby/util/module_test.rb

@@ -0,0 +1,29 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/module'
+
+module Outer
+  module Middle
+    module InnerModule; end
+    class InnerClass; end
+  end
+end
+
+class ModuleTest < Test::Unit::TestCase
+  def test_top_level_module_with_name
+    assert_equal(Array, Module.module_with_name(nil, 'Array'), "Top level module incorrect")
+  end
+
+  def test_module_with_unqualified_name
+    assert_equal(Outer::Middle, Outer.module_with_name('Middle'), "Unqualified module incorrect")
+  end
+
+  def test_module_with_qualified_name
+    assert_equal(Outer::Middle::InnerModule, Outer.module_with_name('Middle::InnerModule'), "Qualified module incorrect")
+  end
+
+  def test_class_with_name
+    assert_equal(Outer::Middle::InnerClass, Outer.module_with_name('Middle::InnerClass'), "Inner class incorrect")
+  end
+end

data/test/lib/caruby/util/options_test.rb

@@ -0,0 +1,59 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/options'
+
+class OptionsTest < Test::Unit::TestCase
+  def test_present
+    assert(Options.get(:key, {:key => true}), "Option true value not returned")
+    assert(!Options.get(:key, {:key => false}), "Option true value not returned")
+  end
+
+  def test_nil_value
+    assert_equal(:a, Options.get(:key, {:key => nil}, :a), "Options nil value not returned")
+  end
+
+  def test_false_with_true_default
+    assert_equal(false, Options.get(:key, {:key => false}, true), "Option false value with true default doesn't return false")
+  end
+
+  def test_missing
+    assert_nil(Options.get(:key, {}), "Missing option incorrectly found")
+  end
+
+  def test_default_value
+    assert_equal(:a, Options.get(:key, {}, :a), "Option default value not used")
+  end
+
+  def test_default_block
+    assert_equal(:b, Options.get(:key, {}) { :b }, "Option default block not called")
+  end
+
+  def test_symbol
+    assert(Options.get(:key, :key), "Option not found in singleton options")
+  end
+
+  def test_array
+    assert(Options.get(:b, [:a, :b]), "Option not found in array options")
+  end
+
+  def test_collection_value
+    assert_equal([:a], Options.get(:key, {:key => [:a]}, []), "Option array value not returned")
+  end
+  
+  def test_empty_to_hash
+    assert_equal({}, Options.to_hash(), "Option to_hash with empty argument list not an empty hash")
+  end
+  
+  def test_nil_to_hash
+    assert_equal({}, Options.to_hash(nil), "Option to_hash with nil argument list not an empty hash")
+  end
+  
+  def test_hash_to_hash
+    assert_equal({:a => 1}, Options.to_hash({:a => 1}), "Option to_hash with hash argument list not an empty hash")
+  end
+  
+  def test_lish_to_hash
+    assert_equal({:a => 1, :b => true, :c => [2, 3]}, Options.to_hash(:a, 1, :b, :c, 2, 3), "Option to_hash with list argument list incorrect")
+  end
+end

data/test/lib/caruby/util/partial_order_test.rb

@@ -0,0 +1,41 @@
+$:.unshift 'lib'
+
+require "test/unit"
+require 'caruby/util/partial_order'
+
+class Queued
+  include PartialOrder
+
+  attr_reader :value, :queue
+
+  def initialize(value, on)
+    @value = value
+    @queue = on.push(self)
+  end
+
+  def <=>(other)
+    value <=> other.value if queue.equal?(other.queue)
+  end
+end
+
+class PartialOrderTest < Test::Unit::TestCase
+  def test_same_queue
+    @a = Queued.new(1, [])
+    assert_equal(@a, @a.dup, "Same value, queue not equal")
+  end
+
+  def test_different_eql_queue
+    @a = Queued.new(1, [])
+    @b = Queued.new(1, [])
+    assert_nil(@a <=> @b, "Same value, different queue <=> not nil")
+    assert_not_equal(@a, @b, "Same value, different queue is equal")
+  end
+
+  def test_less_than
+    @a = Queued.new(1, [])
+    @b = Queued.new(2, @a.queue)
+    @c = Queued.new(2, [])
+    assert(@a < @b, "Comparison incorrect")
+    assert_nil(@a < @c, "Comparison incorrect")
+  end
+end

data/test/lib/caruby/util/person_test.rb

@@ -0,0 +1,115 @@
+$:.unshift 'lib'
+$:.unshift '../caruby/lib'
+
+require "test/unit"
+require 'caruby/util/person'
+
+class PersonTest < Test::Unit::TestCase
+  def test_middle_but_no_first
+    assert_raises(ValidationError) { || CaRuby::Person::Name.new('Longfellow', nil, 'Wadsworth').validate }
+  end
+
+  def test_empty_middle_and_no_first
+    assert_raises(ValidationError) { || CaRuby::Person::Name.new(nil, '').validate }
+  end
+
+  def test_substitute_nil_for_empty
+    name = CaRuby::Person::Name.new('Longfellow', '')
+    assert_nil(name.first)
+  end
+
+  def test_full_print
+    name = CaRuby::Person::Name.new('Longfellow', 'Henry', 'W.')
+    assert_equal('Henry W. Longfellow', name.to_s)
+  end
+
+  def test_first_and_last_print
+    name = CaRuby::Person::Name.new('Longfellow', 'Henry')
+    assert_equal('Henry Longfellow', name.to_s)
+  end
+
+  def test_last_print
+    name = CaRuby::Person::Name.new('Longfellow', '')
+    assert_equal('Longfellow', name.to_s)
+  end
+
+  def test_first_print
+    name = CaRuby::Person::Name.new('', 'Henry')
+    assert_equal('Henry', name.to_s)
+  end
+
+  def test_parse_last_first
+    name = CaRuby::Person::Name.parse('Longfellow, Henry')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_nil(name.middle)
+  end
+
+  def test_parse_last_first_middle
+    name = CaRuby::Person::Name.parse('Longfellow, Henry Wadsworth')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Wadsworth', name.middle)
+  end
+
+  def test_parse_last_first_middles
+    name = CaRuby::Person::Name.parse('Longfellow, Henry Gallifant Wadsworth')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Gallifant Wadsworth', name.middle)
+  end
+
+  def test_parse_first_last
+    name = CaRuby::Person::Name.parse('Henry Longfellow')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_nil(name.middle)
+  end
+
+  def test_parse_first_middle_Last
+    name = CaRuby::Person::Name.parse('Henry Wadsworth Longfellow')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Wadsworth', name.middle)
+  end
+
+  def test_salutation_with_middle
+    name = CaRuby::Person::Name.parse('Mr. Henry Wadsworth Longfellow')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Wadsworth', name.middle)
+    assert_equal('Mr.', name.salutation)
+  end
+
+  def test_salutation_without_middle
+    name = CaRuby::Person::Name.parse('Mr. Henry Longfellow')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Mr.', name.salutation)
+  end
+
+  def test_qualifier
+    name = CaRuby::Person::Name.parse('Henry Wadsworth Longfellow III')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Wadsworth', name.middle)
+    assert_equal('III', name.qualifier)
+  end
+
+  def test_credentials
+    name = CaRuby::Person::Name.parse('Henry Wadsworth Longfellow, MD, Ph.D., CPA, Esq')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Wadsworth', name.middle)
+    assert_equal('MD, Ph.D., CPA, Esq', name.credentials)
+  end
+
+  def test_qualifier_and_credentials
+    name = CaRuby::Person::Name.parse('Henry Wadsworth Longfellow III, Ph.D.')
+    assert_equal('Henry', name.first)
+    assert_equal('Longfellow', name.last)
+    assert_equal('Wadsworth', name.middle)
+    assert_equal('III', name.qualifier)
+    assert_equal('Ph.D.', name.credentials)
+  end
+end