tap 0.8.0 → 0.9.0

data/test/support/batchable_test.rb

@@ -0,0 +1,74 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/batchable'
+
+class BatchableTest < Test::Unit::TestCase
+
+  class BatchableClass
+    include Tap::Support::Batchable
+    def initialize
+      @batch = []
+      initialize_batch_obj
+    end
+  end
+  
+  attr_accessor :t
+  
+  def setup
+    @t = BatchableClass.new
+  end
+
+  #
+  # batch test
+  #
+  
+  def test_batch_documentation
+    t1 = Tap::Task.new
+    t2 = Tap::Task.new
+    t3 = t2.initialize_batch_obj
+  
+    Tap::Support::Batchable.batch(t1, t2)
+    assert_equal [t1,t2,t3], t3.batch
+  end
+  
+  #
+  # batched? test
+  #
+  
+  def test_batched_returns_true_if_batch_size_is_greater_than_one
+    assert !t.batched?
+    assert_equal 1, t.batch.size
+    
+    t1 = t.initialize_batch_obj
+    
+    assert t.batched?
+    assert t1.batched?
+  end
+  
+  #
+  # batch_index test
+  #
+  
+  def test_batch_index_returns_the_index_of_the_task_in_batch
+    t1 = t.initialize_batch_obj
+    
+    assert_equal [t, t1], t.batch
+    assert_equal 0, t.batch_index
+    assert_equal 1, t1.batch_index
+  end
+  
+  #
+  # initialize_batch_obj test
+  #
+  
+  def test_created_batch_tasks_are_added_to_and_share_the_same_execute_batch
+    assert_equal [t], t.batch
+    
+    t1 = t.initialize_batch_obj
+    t2 = t1.initialize_batch_obj
+    
+    assert_equal [t, t1, t2], t.batch
+    assert_equal t.batch.object_id, t1.batch.object_id
+    assert_equal t.batch.object_id, t2.batch.object_id
+  end
+
+end

data/test/support/{task_configuration_test.rb → class_configuration_test.rb}

@@ -1,24 +1,85 @@
 require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/task_configuration'
-require 'tap/task'
+require 'tap/support/class_configuration'
+require 'tap/support/validation'
+require 'tap/support/configurable_methods'
+require 'tap/support/tdoc'
+require 'tap/support/configurable'
 
 # for documentation test
-class BaseTask < Tap::Task
+class BaseTask 
+  include Tap::Support::Configurable
   config :one, 1
 end
 class SubTask < BaseTask
   config :one, 'one'
   config :two, 'two'
 end
+class MergeTask < BaseTask
+  config :three, 'three'
+  config_merge SubTask
+end
+class ValidationTask < Tap::Task
+  config :one, 'one', &c.check(String)
+  config :two, 'two', &c.yaml(/two/, Integer)
+  config :three, 'three' do |v| 
+    v =~ /three/ ? v.upcase : raise("not three")
+  end
+end
 
-class TaskConfigurationTest < Test::Unit::TestCase
+class ClassConfigurationTest < Test::Unit::TestCase
   include Tap::Support
   
+  def test_config_merge
+    t = MergeTask.new
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.config)
+    assert t.respond_to?(:two)
+    yaml = MergeTask.configurations.format_yaml
+    expected = %Q{
+# BaseTask configuration
+one: one
+
+# MergeTask configuration
+three: three
+
+# SubTask configuration
+two: two
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 'one', 'two' => 'two', 'three' => 'three'}, YAML.load(yaml))
+  end
+  
+  def test_config_validations
+    t = ValidationTask.new
+    assert_equal({:one => 'one', :two => 'two', :three => 'THREE'}, t.config)
+    
+    t.one = 'two'
+    assert_equal 'two', t.one  
+    assert_raise(Validation::ValidationError) { t.one = 1 }
+    
+    t.two = "two"
+    assert_equal 'two', t.two
+    t.two = 2
+    assert_equal 2, t.two    
+    t.two = "2"
+    assert_equal 2, t.two
+    assert_raise(Validation::ValidationError) { t.two = 'three' }
+    assert_raise(Validation::ValidationError) { t.two = 2.2 }
+    
+    t.three = "three"
+    assert_equal 'THREE', t.three
+    assert_raise(RuntimeError) { t.three = 'THREE' } 
+  end
+  
   def test_initialization
-    c = TaskConfiguration.new
-    assert_equal({}, c.declarations)
+    c = ClassConfiguration.new ClassConfigurationTest
+    
+    assert_equal ClassConfigurationTest, c.receiver
+    assert_equal [], c.declarations
+    assert_equal [[c.receiver, []]], c.declarations_array
     assert_equal({}, c.default)
-    assert_equal({}, c.attributes)
+    assert_equal({}, c.unprocessed_default)
+    assert_equal({}, c.process_blocks)
   end
 
   #
@@ -26,13 +87,12 @@ class TaskConfigurationTest < Test::Unit::TestCase
   #
   
   def test_format_yaml_with_single_class
-    cc = TaskConfiguration.new
-    cc.declare('one', TaskConfigurationTest)
-    cc.set('one', 1)
+    cc = ClassConfiguration.new ClassConfigurationTest
+    cc.add('one', 1)
     
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 one: 1
 }
     
@@ -41,13 +101,12 @@ one: 1
   end
 
   def test_format_stringifies_keys
-    cc = TaskConfiguration.new
-    cc.declare(:one, TaskConfigurationTest)
-    cc.set(:one, 1)
+    cc = ClassConfiguration.new ClassConfigurationTest
+    cc.add(:one, 1)
     
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 one: 1
 }
 
@@ -57,13 +116,13 @@ one: 1
 end 
 class Hold
   def test_format_yaml_with_desc
-    cc = TaskConfiguration.new
-    cc.declare('one', TaskConfigurationTest)
+    cc = ClassConfiguration.new
+    cc.declare('one', ClassConfigurationTest)
     cc.set('one', 1, :desc => "comment")
     
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 one: 1               # comment
 }
 
@@ -72,13 +131,13 @@ one: 1               # comment
   end
 
   def test_format_yaml_with_long_desc
-    cc = TaskConfiguration.new
-    cc.declare('one', TaskConfigurationTest)
+    cc = ClassConfiguration.new
+    cc.declare('one', ClassConfigurationTest)
     cc.set('one', 1, :desc => 'comment longer than some twenty chars')
 
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 # comment longer than some twenty chars
 one: 1
 }
@@ -88,10 +147,10 @@ one: 1
   end
 
   def test_format_yaml_with_long_value
-    cc = TaskConfiguration.new(['one', 'value longer than some twenty chars', 'comment', TaskConfigurationTest])
+    cc = ClassConfiguration.new(['one', 'value longer than some twenty chars', 'comment', ClassConfigurationTest])
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 # comment
 one: value longer than some twenty chars
 }
@@ -101,10 +160,10 @@ one: value longer than some twenty chars
   end
   
 #   def test_format_yaml_with_nil_value
-#     cc = TaskConfiguration.new(['one', nil, 'comment', TaskConfigurationTest])
+#     cc = ClassConfiguration.new(['one', nil, 'comment', ClassConfigurationTest])
 #     yaml = cc.format_yaml
 #     expected = %Q{
-# # TaskConfigurationTest configuration
+# # ClassConfigurationTest configuration
 # #one:                # comment
 # }
 # 
@@ -113,10 +172,10 @@ one: value longer than some twenty chars
 #   end
   
   def test_format_yaml_with_multiline_comment
-    cc = TaskConfiguration.new(['one', 1, "multiline\ncomment", TaskConfigurationTest])
+    cc = ClassConfiguration.new(['one', 1, "multiline\ncomment", ClassConfigurationTest])
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 # multiline
 # comment
 one: 1
@@ -127,10 +186,10 @@ one: 1
   end
   
   def test_format_yaml_with_multiline_value
-    cc = TaskConfiguration.new(['one', [1,2,3], "comment", TaskConfigurationTest])
+    cc = ClassConfiguration.new(['one', [1,2,3], "comment", ClassConfigurationTest])
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 # comment
 one: 
 - 1
@@ -143,17 +202,17 @@ one:
   end
   
   def test_format_yaml_with_multiple_classes
-    cc = TaskConfiguration.new(
-      ['one', 1, '', TaskConfigurationTest],
+    cc = ClassConfiguration.new(
+      ['one', 1, '', ClassConfigurationTest],
       ['one', 'one', 'integer', AnotherClass],
       ['two', {'key' => 'value'}, 'hash', AnotherClass],
       ['three', [1,2,3], "multiline\narray", AnotherClass])
     yaml = cc.format_yaml
     expected = %Q{
-# TaskConfigurationTest configuration
+# ClassConfigurationTest configuration
 one: one             # integer
 
-# TaskConfigurationTest::AnotherClass configurations
+# ClassConfigurationTest::AnotherClass configurations
 # hash
 two: 
   key: value
@@ -196,30 +255,30 @@ class Hold
   end
   
   def test_add
-    cc = TaskConfiguration.new
-    cc.add(:key, 'value', TaskConfigurationTest)
+    cc = ClassConfiguration.new
+    cc.add(:key, 'value', ClassConfigurationTest)
     
-    assert_equal [[:key, 'value', TaskConfigurationTest]], cc.declarations
+    assert_equal [[:key, 'value', ClassConfigurationTest]], cc.declarations
     assert_equal({:key => 'value'}, cc.hash)
     
     cc.add(:key, 'new value', AnotherClass)  
     assert_equal [
-      [:key, 'value', TaskConfigurationTest], 
+      [:key, 'value', ClassConfigurationTest], 
       [:key, 'new value', AnotherClass]
     ], cc.declarations
     assert_equal({:key => 'new value'}, cc.hash)
   end
   
   def test_add_symbolizes_keys
-    cc = TaskConfiguration.new
-    cc.add('key', 'value', TaskConfigurationTest)
+    cc = ClassConfiguration.new
+    cc.add('key', 'value', ClassConfigurationTest)
     
-    assert_equal [[:key, 'value', TaskConfigurationTest]], cc.declarations
+    assert_equal [[:key, 'value', ClassConfigurationTest]], cc.declarations
     assert_equal({:key => 'value'}, cc.hash)
   end
 
   # def test_add_raises_error_if_declarations_are_not_correct
-  #   cc = TaskConfiguration.new
+  #   cc = ClassConfiguration.new
   #   assert_raise(ArgumentError) { cc.add(:key, 'value')}
   #   assert_raise(ArgumentError) { cc.add([:key, 'value'])}
   # end
@@ -229,8 +288,8 @@ class Hold
   #
   
   def test_remove
-    cc = TaskConfiguration.new(
-      [:one, 1, TaskConfigurationTest],
+    cc = ClassConfiguration.new(
+      [:one, 1, ClassConfigurationTest],
       [:one, 'one', AnotherClass],
       [:two, 'two', AnotherClass],
       [:three, 'three', AnotherClass])
@@ -244,7 +303,7 @@ class Hold
   end
   
   def test_remove_symbolizes_inputs
-    cc = TaskConfiguration.new([:key, 'value', TaskConfigurationTest])
+    cc = ClassConfiguration.new([:key, 'value', ClassConfigurationTest])
     cc.remove('key')
     assert_equal [], cc.declarations
   end
@@ -254,16 +313,16 @@ class Hold
   #
   
   # def test_merge
-  #   c1 = TaskConfiguration.new([:one, 1, '', TaskConfigurationTest])
+  #   c1 = ClassConfiguration.new([:one, 1, '', ClassConfigurationTest])
   #   c2 = c1.merge([
   #     [:one, 'one', '', AnotherClass], 
   #     [:two, 'two', '', AnotherClass]])
   #     
   #   assert_not_equal c1.object_id, c2.object_id
   #   
-  #   assert_equal [[:one, 1, '', TaskConfigurationTest]], c1.declarations 
+  #   assert_equal [[:one, 1, '', ClassConfigurationTest]], c1.declarations 
   #   assert_equal [
-  #     [:one, 1, '', TaskConfigurationTest],
+  #     [:one, 1, '', ClassConfigurationTest],
   #     [:one, 'one', '', AnotherClass], 
   #     [:two, 'two', '', AnotherClass]], c2.declarations 
   # end

data/test/support/configurable_test.rb

@@ -0,0 +1,295 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/class_configuration'
+require 'tap/support/validation'
+require 'tap/support/configurable_methods'
+require 'tap/support/tdoc'
+require 'tap/support/configurable'
+
+# for documentation test
+# class BaseTask 
+#   include Tap::Support::Configurable
+#   config :one, 1
+# end
+# class SubTask < BaseTask
+#   config :one, 'one'
+#   config :two, 'two'
+# end
+# 
+
+class ConfigurableTest < Test::Unit::TestCase
+  acts_as_tap_test
+
+  class ConfigurableClassWithNoConfigs
+    include Tap::Support::Configurable
+  end
+  
+  class ConfigurableClass
+    include Tap::Support::Configurable
+    
+    config :one, 'one'
+    config :two, 'two'
+    config :three, 'three'
+  end
+
+  def setup
+    super
+    app.root = trs.root
+  end
+  
+  def test_configurable_doc
+    t = ConfigurableClass.new 
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.config)
+  end
+  
+  #
+  # include test
+  #
+  
+  def test_include_extends_class_with_ConfigurableMethods
+    assert ConfigurableClassWithNoConfigs.kind_of?(Tap::Support::ConfigurableMethods)
+  end
+  
+  #
+  # default_name test
+  #
+  
+  def test_default_name
+    assert_equal "configurable_test/configurable_class", ConfigurableClass.default_name
+  end
+  
+  #
+  # name test
+  #
+  
+  def test_name_is_initialized_to_class_default_name_unless_specified
+    assert_equal ConfigurableClass.default_name, ConfigurableClass.new.name
+    assert_equal "alt", ConfigurableClass.new("alt").name
+  end
+
+  # config_file test
+  #
+  
+  def test_config_file_is_app_config_filepath_when_config_file_exist
+    t = ConfigurableClass.new "configured"
+    app_config_filepath = app.config_filepath("configured")
+    
+    assert_equal File.join(t.app['config'], "configured.yml"),app_config_filepath
+    assert File.exists?(app_config_filepath)
+    assert_equal app.config_filepath("configured"), t.config_file
+  end
+
+  def test_config_file_is_nil_for_nil_input_names
+    t = ConfigurableClass.new 
+    assert_equal nil, t.config_file
+    
+    t = ConfigurableClass.new nil
+    assert_equal nil, t.config_file
+  end
+  
+  #
+  # config tests
+  #
+  
+  class SampleClass
+    include Tap::Support::Configurable
+    
+    config :key, 'value'
+    config_reader
+    config :reader_only
+  end
+  
+  class ValidatingClass
+    include Tap::Support::Configurable
+
+    config :one, 'one', &c.check(String)
+    config :two, 'two' do |v| 
+      v.upcase
+    end
+  end
+  
+  def test_config_doc
+    t = SampleClass.new
+    assert t.respond_to?(:reader_only)
+    assert !t.respond_to?(:reader_only=)
+  
+    assert_equal({:key => 'value', :reader_only => nil}, t.config)
+    assert_equal 'value', t.key  
+    t.key = 'another'
+    assert_equal({:key => 'another', :reader_only => nil}, t.config)
+    
+    t = ValidatingClass.new
+    assert_equal({:one => 'one', :two => 'TWO'}, t.config)
+    assert_raise(Tap::Support::Validation::ValidationError) { t.one = 1 }
+    assert_raise(Tap::Support::Validation::ValidationError) { t.config = {:one => 1} }
+    
+    t.config = {:one => 'str', :two => 'str'}
+    assert_equal({:one => 'str', :two => 'STR'}, t.config)
+  end
+  
+  def test_config_sets_config
+    t = ConfigurableClassWithNoConfigs.new
+    assert_equal({}, t.config)
+    t.config = {:key => 'value'}
+    assert_equal({:key => 'value'}, t.config)
+  end
+  
+  def test_config_merges_default_config_and_overrides
+    t = ConfigurableClass.new "configured"
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.configurations.default)
+    assert_equal({:one => 'one', :two => 'TWO', :three => 'THREE'}, t.config)
+    
+    t.config = {:three => 3}
+    assert_equal({:one => 'one', :two => 'two', :three => 3}, t.config)
+  end
+  
+  class ConfigurableClassWithManyConfigs
+    include Tap::Support::Configurable
+    
+    config :one, 'one'
+    
+    declare_config
+    config :two, 'two'
+    
+    config_reader
+    config :three, 'three'
+    
+    config_writer
+    config :four, 'four'
+    
+    config_accessor
+    config :five, 'five'
+    
+    declare_config :six
+    config_reader :seven
+    config_writer :eight
+    config_accessor :nine
+  end
+  
+  def test_config_with_many_configs
+    t = ConfigurableClassWithManyConfigs.new
+    
+    assert_equal({
+      :one => 'one',     :six => nil, 
+      :two => 'two',     :seven => nil,
+      :three => 'three', :eight => nil,
+      :four => 'four',   :nine => nil,
+      :five => 'five'},
+    t.config)
+    
+    # readers only
+    [:three, :seven].each do |config|
+      assert t.respond_to?(config)
+      assert !t.respond_to?("#{config}=")
+    end
+    
+    # writers only
+    [:four, :eight].each do |config|
+      assert !t.respond_to?(config)
+      assert t.respond_to?("#{config}=")
+    end
+  
+    # both
+    [:one, :five, :nine].each do |config|
+      assert t.respond_to?(config)
+      assert t.respond_to?("#{config}=")
+    end
+    
+    # neither
+    [:two, :six].each do |config|
+      assert !t.respond_to?(config)
+      assert !t.respond_to?("#{config}=")
+    end
+  end
+
+  #
+  # test subclass behavior
+  #
+  
+  class DeclarationClass
+    include Tap::Support::Configurable
+    
+    declare_config
+
+    config :one, 1
+    config :two, 2
+    config :three, 3
+
+    config_accessor :one
+    config_writer :two
+    config_reader :three
+  end
+  
+  class DeclarationSubClass < DeclarationClass
+    config :one, "one"
+    config :four, 4
+  end
+  
+  def test_config_accessors_are_inherited
+    t = DeclarationSubClass.new
+    
+    assert t.respond_to?(:one)
+    assert t.respond_to?("one=")
+    assert !t.respond_to?(:two)
+    assert t.respond_to?("two=")
+    assert t.respond_to?(:three)
+    assert !t.respond_to?("three=")
+    
+    assert t.respond_to?(:four)
+    assert t.respond_to?("four=")
+  end
+  
+  def test_class_configurations_are_inherited_but_can_be_overridden
+    assert_equal([
+      [DeclarationClass, [:one, :two, :three]],
+      [DeclarationSubClass, [:four]]
+    ], DeclarationSubClass.configurations.declarations_array)
+    
+    assert_equal({:one => 1, :two => 2, :three => 3}, DeclarationClass.configurations.default)
+    assert_equal({:one => 'one', :two => 2, :three => 3, :four => 4}, DeclarationSubClass.configurations.default)
+    
+    t = DeclarationSubClass.new
+    assert_equal({:one => 'one', :two => 2, :three => 3, :four => 4}, t.config)
+  end
+  
+  #
+  # initialize_batch_obj test
+  #
+  
+  def test_initialize_batch_obj_merges_default_config_and_overrides
+    t = ConfigurableClass.new "configured", :three => 3
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t.class.configurations.default)
+    assert_equal({:one => 'one', :two => 'TWO', :three => 3}, t.config)
+    
+    t1 = t.initialize_batch_obj
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, t1.config)  
+    
+    t2 = t.initialize_batch_obj(nil, {:three => 3})
+    assert_equal({:one => 'one', :two => 'two', :three => 3}, t2.config)
+  end
+  
+  
+  # include Tap::Support
+  # 
+  # def test_config_validations
+  #   t = ValidationTask.new
+  #   assert_equal({:one => 'one', :two => 'two', :three => 'THREE'}, t.config)
+  #   
+  #   t.one = 'two'
+  #   assert_equal 'two', t.one  
+  #   assert_raise(Validation::ValidationError) { t.one = 1 }
+  #   
+  #   t.two = "two"
+  #   assert_equal 'two', t.two
+  #   t.two = 2
+  #   assert_equal 2, t.two    
+  #   t.two = "2"
+  #   assert_equal 2, t.two
+  #   assert_raise(Validation::ValidationError) { t.two = 'three' }
+  #   assert_raise(Validation::ValidationError) { t.two = 2.2 }
+  #   
+  #   t.three = "three"
+  #   assert_equal 'THREE', t.three
+  #   assert_raise(RuntimeError) { t.three = 'THREE' } 
+  # end
+
+end