tap 0.9.1 → 0.10.0

data/test/support/configurable/config/configured.yml

@@ -1,2 +0,0 @@
-two: TWO
-three: THREE

data/test/support/configurable_test.rb

@@ -1,295 +0,0 @@
-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

data/test/support/executable_queue_test.rb

@@ -1,103 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/executable_queue'
-
-class ExecutableQueueTest < Test::Unit::TestCase
-  include Tap::Support
-  
-  attr_accessor :m, :queue
- 
-  def setup
-    @m = Object.new.extend Executable
-    @queue = ExecutableQueue.new
-  end
-  
-  #
-  # initialization tests
-  #
-  
-  def test_initialize
-    q = ExecutableQueue.new
-    assert q.empty?
-  end
-  
-  #
-  # size, clear, empty? tests
-  #
-  
-  def test_size_return_number_of_tasks
-    assert_equal 0, queue.size
-    queue.enq m, []
-    assert_equal 1, queue.size
-  end
-
-  def test_empty_is_true_if_tasks_is_empty
-    assert queue.empty?
-    queue.enq m, []
-    assert !queue.empty?
-  end
-  
-  def test_clear_resets_tasks_and_task_inputs
-    assert_equal([], queue.to_a)
-    
-    queue.enq m, []
-    queue.clear
-    
-    assert_equal([], queue.to_a)
-  end
-  
-  def test_clear_returns_existing_queue_as_an_array
-    assert_equal([], queue.to_a)
-    
-    queue.enq m, []
-    assert_equal [[m, []]], queue.clear
-  end
-  
-  #
-  # queue test
-  #
-  
-  def test_enq_pushes_task_and_inputs_onto_queue
-    assert_equal [], queue.to_a
-    
-    queue.enq(m, [1])
-    assert_equal [[m,[1]]], queue.to_a
-
-    queue.enq(m, [2])
-    assert_equal [[m,[1]], [m,[2]]], queue.to_a
-  end
-  
-  def test_enq_raises_error_for_non_task_methods
-    assert_raise(RuntimeError) { queue.enq(method(:setup), [1]) }
-  end
-  
-  #
-  # unshift test
-  #
-  
-  def test_unshift
-    assert_equal [], queue.to_a
-    
-    queue.unshift(m, [1])
-    assert_equal [[m,[1]]], queue.to_a
-
-    queue.unshift(m, [2])
-    assert_equal [[m,[2]], [m,[1]]], queue.to_a
-  end
-
-  def test_unshift_raises_error_for_non_task_methods
-    assert_raise(RuntimeError) { queue.unshift(method(:setup), [1]) }
-  end
-  
-  #
-  # deq test
-  #
-  
-  def test_deq
-    queue.enq(m, [1])
-    queue.enq(m, [2])
-    
-    assert_equal [m, [1]], queue.deq
-    assert_equal [m, [2]], queue.deq
-  end
-  
-end

data/test/support/executable_test.rb

@@ -1,38 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/executable'
-
-class ExecutableTest < Test::Unit::TestCase
-  include Tap
-
-  attr_accessor :m
-  
-  def setup
-    @m = Tap::Support::Executable.initialize(Object.new, :object_id)
-  end
-  
-  #
-  # initialization tests
-  #
-  
-  def test_initialization
-    assert !m.multithread
-    assert_nil m.on_complete_block
-  end
-  
-  #
-  # on_complete block test
-  #
-  
-  def test_on_complete_sets_on_complete_block
-    block = lambda {}
-    m.on_complete(&block)
-    assert_equal block, m.on_complete_block
-  end
-  
-  def test_on_complete_can_only_be_set_once
-    m.on_complete {}
-    assert_raise(RuntimeError) { m.on_complete {} }
-    assert_raise(RuntimeError) { m.on_complete }
-  end
-
-end

data/test/support/logger_test.rb

@@ -1,31 +0,0 @@
-require  File.join(File.dirname(__FILE__), '../tap_test_helper')
-require 'tap/support/logger'
-require 'stringio'
-
-class LoggerTest < Test::Unit::TestCase
-  include Tap
-
-  #
-  # logger tests
-  #
-  
-  def test_logger
-    output = StringIO.new('')
-    logger = Logger.new(output).extend Support::Logger
-    logger.datetime_format = '%H:%M:%S'
-    logger.subject 'message'
-    
-    assert output.string =~ /^\s+I\[\d\d:\d\d:\d\d\]\s+subject\s+message/, output.string
-  end
-  
-  def test_logdev_returns_the_log_device
-    [StringIO.new(''), STDOUT].each do |device|
-      logger = Logger.new(device)
-      assert !logger.respond_to?(:logdev)
-      
-      logger.extend Support::Logger
-      assert_equal Logger::LogDevice, logger.logdev.class
-      assert_equal device, logger.logdev.dev
-    end
-  end
-end