tap 0.7.9 → 0.8.0

data/test/script_test.rb

@@ -0,0 +1,194 @@
+require  File.join(File.dirname(__FILE__), 'tap_test_helper')
+require 'tap/script'
+
+class ScriptConfigTest < Test::Unit::TestCase
+  include Tap
+  
+  acts_as_tap_test
+  
+  #
+  # class default tests
+  #
+  
+  def test_defaults
+    assert_equal({
+      :gems => [], 
+      :load_once_paths => [], 
+      :load_paths => ["lib"],
+      :script_paths => ["script"]},
+    ScriptConfig.defaults)
+  end
+  
+  #
+  # class spec_filepath test
+  #
+  
+  def test_spec_filepath
+    assert_equal "tapspec.yml", ScriptConfig.spec_filepath
+    assert_equal "path/to/dir/tapspec.yml", ScriptConfig.spec_filepath("path/to/dir")
+  end
+  
+  #
+  # default script config
+  #
+  
+  def test_default_script_config
+    config = ScriptConfig.new
+    assert config.kind_of?(OpenStruct)
+    assert_equal({
+      :gems => [],
+      :gemspecs => [], 
+      :load_once_paths => [], 
+      :load_paths => [app["lib"]],
+      :script_paths => [app["script"]]},
+    config.marshal_dump)
+  end
+  
+  def test_script_config_with_inputs
+    config = ScriptConfig.new :key => 'value', :load_paths => ['lib', 'test']
+
+    assert_equal({
+      :gems => [],
+      :gemspecs => [], 
+      :load_once_paths => [], 
+      :load_paths => [app["lib"], app['test']],
+      :script_paths => [app["script"]],
+      :key => 'value'},
+    config.marshal_dump)
+  end
+  
+  def test_single_arguments_are_allowed
+    config = ScriptConfig.new(
+      :load_paths => "alt",
+      :load_once_paths => "once")
+
+    assert_equal({
+      :gems => [],
+      :gemspecs => [], 
+      :load_once_paths => [app["once"]], 
+      :load_paths => [app["alt"]],
+      :script_paths => [app["script"]]},
+    config.marshal_dump)
+  end
+  
+  def test_gemspecs_and_paths_are_collected_for_the_specified_gem
+    config = ScriptConfig.new :gems => 'activesupport'
+    spec = Gem.loaded_specs["activesupport"]
+    
+    assert_equal 'activesupport', config.gems
+    assert_equal [spec], config.gemspecs
+    assert_equal [app['lib'], File.join(spec.full_gem_path, 'lib')], config.load_paths
+    assert_equal [app['script'], File.join(spec.full_gem_path, 'script')], config.script_paths
+  end
+  
+  #
+  # TODO -- find a way to test the gem loading behavior,  
+  # especially when the tapspec contains nested gems
+  # and when the tapspec contains unsafe filepaths
+  #
+  
+  #
+  # TODO -- test scripts
+  #
+end
+
+class ScriptTest < Test::Unit::TestCase
+
+  acts_as_tap_test
+  
+  def setup
+    super  
+    @load_path_hold = $LOAD_PATH.dup
+    Dependencies.load_paths.clear
+    Dependencies.load_once_paths.clear
+    
+    script.reset
+  end
+
+  def teardown
+    super
+    $LOAD_PATH.clear
+    $LOAD_PATH.concat @load_path_hold
+    Dependencies.load_paths.clear
+    Dependencies.load_once_paths.clear
+  end
+  
+  def script
+    Tap::Script.instance
+  end
+  
+  def tap_lib_dir
+    File.expand_path(File.dirname(__FILE__) + "/../lib")
+  end
+
+  #
+  # configure_app tests
+  #
+  
+  def test_configure_returns_an_appropriate_script_config
+    config = script.configure_app
+
+    assert_equal [], config.gemspecs
+    assert_equal [], config.load_once_paths
+    assert_equal [tap_lib_dir, app['lib']], config.load_paths
+    assert_equal [app['script']], config.script_paths
+    
+    config = script.configure_app :load_paths => ['alt'], :key => 'value'
+
+    assert_equal [], config.gemspecs
+    assert_equal [], config.load_once_paths
+    assert_equal [tap_lib_dir, app['alt']], config.load_paths
+    assert_equal [app['script']], config.script_paths
+    assert_equal 'value', config.key
+  end
+  
+  def test_configure_app_sets_default_load_and_script_paths
+    assert !$LOAD_PATH.include?( app['lib'] )
+    assert_equal [], Dependencies.load_paths
+    assert_equal [], Dependencies.load_once_paths
+    
+    script.configure_app
+
+    assert $LOAD_PATH.include?( app['lib'] )
+    
+    assert_equal [tap_lib_dir, app['lib']], Dependencies.load_paths
+    assert_equal [], Dependencies.load_once_paths
+  end
+
+  def test_configure_app_resolves_aliases_and_sets_paths
+    app['lib'] = "alt_lib"
+    app['script'] = "alt_script"
+    app['load_once'] = "load/once/lib"
+    
+    assert !$LOAD_PATH.include?( app['lib'] )
+    assert_equal [], Dependencies.load_paths
+    assert_equal [], Dependencies.load_once_paths
+    
+    script.configure_app(
+      :load_paths => ["lib", "load_once"],
+      :load_once_paths => ["load_once"],
+      :script_paths => ['script'])
+
+    assert $LOAD_PATH.include?( app['lib'] )
+    assert $LOAD_PATH.include?( app['load_once'] )
+    
+    assert_equal [tap_lib_dir, app['lib'], app['load_once']], Dependencies.load_paths
+    assert_equal [app['load_once']], Dependencies.load_once_paths
+  end
+  
+  def test_configure_app_raises_error_if_load_once_path_is_not_a_load_path
+    assert_raise(RuntimeError) do
+      script.configure_app(
+        :load_paths => [],
+        :load_once_paths => ["lib"])
+    end
+  end
+  
+  #
+  # split_to_length test
+  #
+  
+  # def test_split_to_length
+  #   assert_equal ["a a a a", "aaa aa ","a      "], Tap::Script.split_to_length("a a a a aaa aa \na", 7)
+  # end
+end

data/test/support/audit_test.rb

@@ -394,6 +394,9 @@ class AuditTest < Test::Unit::TestCase
   #
   
   def test_documentation
+    # reset the app, in case it is in an unexpected state
+    Tap::App.instance = nil  
+    
     # part 1
     audit = Audit.new(3)
     audit._record(:a, 4)
@@ -436,8 +439,8 @@ class AuditTest < Test::Unit::TestCase
     
     # part 4
     t = Tap::Task.new do |task, input|
-        assert_equal Fixnum, input.class
-        input += 1
+      assert_equal Fixnum, input.class
+      input += 1
     end
     
     results = t.execute(3)   

data/test/support/combinator_test.rb

@@ -26,11 +26,11 @@ class CombinatorTest < Test::Unit::TestCase
 		assert_equal [], c.a
 		assert_equal [], c.b
 		
-		case_test(
+	  {
 			[[1], [2,3], [3, [4]]] =>[[[1]], [[2], [3]], [[3],[[4]]]], 	# arrays have each element arrayified 
 			[nil, nil, nil] => [[], [], []],		                        # nil returns an empty array
 			[[], [{:one => 1},nil], nil] => [[], [[{:one => 1}],[nil]], []]	    # mixture
-		) do |sets, expected|
+		}.each_pair do |sets, expected|
 			c = Combinator.new(*sets)
 			assert_equal expected[0], c.a
 			assert_equal Combinator, c.b.class
@@ -40,11 +40,11 @@ class CombinatorTest < Test::Unit::TestCase
 	end
 	
 	def test_initialize_raises_error_unless_sets_are_all_arrays_combinators_or_nil
-	  acase_test(
+	  [
 	    [1], 
 	    [[], 1], 
 	    [1,[]]
-	  ) do |sets|
+	  ].each do |sets|
 	    assert_raise(ArgumentError) { Combinator.new(*sets) }
 	  end
 	end
@@ -54,14 +54,14 @@ class CombinatorTest < Test::Unit::TestCase
 	#
 	 
 	def test_sets_returns_input_sets_minus_nil_or_empty_arrays
-	  acase_test(
+	  [
 	    [],
 	    [[1]],
 	    [[1], [2]],
 	    [[1], [2,3], [4,5,6]],
 	    [[1], [2,[3]], [4,5,6]],
 	    [[1], nil, [], [4,5,6], nil]
-	  ) do |sets|
+	  ].each do |sets|
 	    expected = sets.reject {|s| s.nil? || s.empty? }
 	    assert_equal expected, Combinator.new(*sets).sets, PP.singleline_pp(sets, "")
 	  end
@@ -72,7 +72,7 @@ class CombinatorTest < Test::Unit::TestCase
 	#
 	
 	def test_length
-	  case_test(
+	  {
 	    [] => 0,
 	    [[1]] => 1,
 	    [[1], [2]] => 1,
@@ -84,7 +84,7 @@ class CombinatorTest < Test::Unit::TestCase
 	    [[1,2], [3,4]] => 4,
 	    [[1,2], [3,4], [5,6]] => 8,
 	    [[1,2], nil, [3,4], [], [5,6]] => 8
-	  ) do |sets, expected|
+	  }.each_pair do |sets, expected|
 	    assert_equal expected, Combinator.new(*sets).length, PP.singleline_pp(sets, "")
 	  end
 	end
@@ -94,7 +94,7 @@ class CombinatorTest < Test::Unit::TestCase
 	#
 	
 	def test_each
-	  case_test(
+	  {
   	  [[1]] => [[1]],
       [[1], [2]] => [[1,2]],
       [[1],[2],[3]] => [[1,2,3]],
@@ -105,7 +105,7 @@ class CombinatorTest < Test::Unit::TestCase
       [[1,2], [3,4]] => [[1,3],[1,4],[2,3],[2,4]],
       [[1,2], [3,4], [5,6]] => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]],
       [[1,2], nil, [3,4], [], [5,6]] => [[1,3,5],[1,3,6],[1,4,5],[1,4,6],[2,3,5],[2,3,6],[2,4,5],[2,4,6]]
-	  ) do |set, expected|
+	  }.each_pair do |set, expected|
 	    comb = Combinator.new(*set)
 	    
   		combinations = []

data/test/support/rake_test.rb

@@ -0,0 +1,35 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+
+class RakeTest < Test::Unit::TestCase
+  acts_as_tap_test
+  
+  def test_tap_with_rake
+    extended_test do
+      require 'tap/support/rake'
+      app.extend Tap::Support::Rake
+      
+      runlist = []
+      t1 = task :task => [:prerequisite] do
+        runlist << :task 
+      end
+      t2 = task :prerequisite do
+        runlist << :prerequisite
+      end
+      
+      assert_equal [], runlist
+      app.run(:task)
+      assert_equal [:prerequisite, :task], runlist
+    
+      # notice the tasks do not get re-run
+      app.run(:task)
+      assert_equal [:prerequisite, :task], runlist
+      
+      # check that Rake still works natively
+      t1.instance_variable_set("@already_invoked", false)
+      t2.instance_variable_set("@already_invoked", false)
+      
+      Rake.application.lookup(:task).invoke
+      assert_equal [:prerequisite, :task, :prerequisite, :task], runlist
+    end
+  end
+end

data/test/support/task_configuration_test.rb

@@ -0,0 +1,272 @@
+require  File.join(File.dirname(__FILE__), '../tap_test_helper')
+require 'tap/support/task_configuration'
+require 'tap/task'
+
+# for documentation test
+class BaseTask < Tap::Task
+  config :one, 1
+end
+class SubTask < BaseTask
+  config :one, 'one'
+  config :two, 'two'
+end
+
+class TaskConfigurationTest < Test::Unit::TestCase
+  include Tap::Support
+  
+  def test_initialization
+    c = TaskConfiguration.new
+    assert_equal({}, c.declarations)
+    assert_equal({}, c.default)
+    assert_equal({}, c.attributes)
+  end
+
+  #
+  # format_yaml tests
+  #
+  
+  def test_format_yaml_with_single_class
+    cc = TaskConfiguration.new
+    cc.declare('one', TaskConfigurationTest)
+    cc.set('one', 1)
+    
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+one: 1
+}
+    
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 1}, YAML.load(yaml))
+  end
+
+  def test_format_stringifies_keys
+    cc = TaskConfiguration.new
+    cc.declare(:one, TaskConfigurationTest)
+    cc.set(:one, 1)
+    
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+one: 1
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 1}, YAML.load(yaml))
+  end
+end 
+class Hold
+  def test_format_yaml_with_desc
+    cc = TaskConfiguration.new
+    cc.declare('one', TaskConfigurationTest)
+    cc.set('one', 1, :desc => "comment")
+    
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+one: 1               # comment
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 1}, YAML.load(yaml))
+  end
+
+  def test_format_yaml_with_long_desc
+    cc = TaskConfiguration.new
+    cc.declare('one', TaskConfigurationTest)
+    cc.set('one', 1, :desc => 'comment longer than some twenty chars')
+
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+# comment longer than some twenty chars
+one: 1
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 1}, YAML.load(yaml))
+  end
+
+  def test_format_yaml_with_long_value
+    cc = TaskConfiguration.new(['one', 'value longer than some twenty chars', 'comment', TaskConfigurationTest])
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+# comment
+one: value longer than some twenty chars
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 'value longer than some twenty chars'}, YAML.load(yaml))
+  end
+  
+#   def test_format_yaml_with_nil_value
+#     cc = TaskConfiguration.new(['one', nil, 'comment', TaskConfigurationTest])
+#     yaml = cc.format_yaml
+#     expected = %Q{
+# # TaskConfigurationTest configuration
+# #one:                # comment
+# }
+# 
+#     assert_equal expected[1..-1], yaml
+#     assert_equal(false, YAML.load(yaml))
+#   end
+  
+  def test_format_yaml_with_multiline_comment
+    cc = TaskConfiguration.new(['one', 1, "multiline\ncomment", TaskConfigurationTest])
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+# multiline
+# comment
+one: 1
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 1}, YAML.load(yaml))
+  end
+  
+  def test_format_yaml_with_multiline_value
+    cc = TaskConfiguration.new(['one', [1,2,3], "comment", TaskConfigurationTest])
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+# comment
+one: 
+- 1
+- 2
+- 3
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => [1,2,3]}, YAML.load(yaml))
+  end
+  
+  def test_format_yaml_with_multiple_classes
+    cc = TaskConfiguration.new(
+      ['one', 1, '', TaskConfigurationTest],
+      ['one', 'one', 'integer', AnotherClass],
+      ['two', {'key' => 'value'}, 'hash', AnotherClass],
+      ['three', [1,2,3], "multiline\narray", AnotherClass])
+    yaml = cc.format_yaml
+    expected = %Q{
+# TaskConfigurationTest configuration
+one: one             # integer
+
+# TaskConfigurationTest::AnotherClass configurations
+# hash
+two: 
+  key: value
+# multiline
+# array
+three: 
+- 1
+- 2
+- 3
+}
+
+    assert_equal expected[1..-1], yaml
+    assert_equal({'one' => 'one', 'two' => {'key' => 'value'}, 'three' => [1,2,3]}, YAML.load(yaml))
+  end
+end
+
+class Hold
+  
+#   def test_documentation
+#     assert_equal({:one => 1}, BaseTask.configurations.hash)
+#     assert_equal({:one => 'one', :two => 'two'}, SubTask.configurations.hash)
+#     
+#     assert_equal "# BaseTask configuration\none: 1\n", BaseTask.configurations.format_yaml    
+#      
+#     expected = %Q{
+# # BaseTask configuration
+# one: one             # the first configuration
+# 
+# # SubTask configuration
+# two: two             # the second configuration
+# }
+#     assert_equal expected[1..-1], SubTask.configurations.format_yaml
+#   end
+
+  #
+  # add configurations
+  #
+  
+  class AnotherClass
+  end
+  
+  def test_add
+    cc = TaskConfiguration.new
+    cc.add(:key, 'value', TaskConfigurationTest)
+    
+    assert_equal [[:key, 'value', TaskConfigurationTest]], cc.declarations
+    assert_equal({:key => 'value'}, cc.hash)
+    
+    cc.add(:key, 'new value', AnotherClass)  
+    assert_equal [
+      [:key, 'value', TaskConfigurationTest], 
+      [: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)
+    
+    assert_equal [[:key, 'value', TaskConfigurationTest]], cc.declarations
+    assert_equal({:key => 'value'}, cc.hash)
+  end
+
+  # def test_add_raises_error_if_declarations_are_not_correct
+  #   cc = TaskConfiguration.new
+  #   assert_raise(ArgumentError) { cc.add(:key, 'value')}
+  #   assert_raise(ArgumentError) { cc.add([:key, 'value'])}
+  # end
+
+  #
+  # remove configurations
+  #
+  
+  def test_remove
+    cc = TaskConfiguration.new(
+      [:one, 1, TaskConfigurationTest],
+      [:one, 'one', AnotherClass],
+      [:two, 'two', AnotherClass],
+      [:three, 'three', AnotherClass])
+    
+    assert_equal 4, cc.declarations.length
+    assert_equal({:one => 'one', :two => 'two', :three => 'three'}, cc.hash)
+    
+    cc.remove(:one, :three)
+    assert_equal [[:two, 'two', AnotherClass]], cc.declarations  
+    assert_equal({:two => 'two'}, cc.hash)
+  end
+  
+  def test_remove_symbolizes_inputs
+    cc = TaskConfiguration.new([:key, 'value', TaskConfigurationTest])
+    cc.remove('key')
+    assert_equal [], cc.declarations
+  end
+
+  #
+  # merge test
+  #
+  
+  # def test_merge
+  #   c1 = TaskConfiguration.new([:one, 1, '', TaskConfigurationTest])
+  #   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, '', TaskConfigurationTest],
+  #     [:one, 'one', '', AnotherClass], 
+  #     [:two, 'two', '', AnotherClass]], c2.declarations 
+  # end
+  
+
+end