masterview 0.2.5 → 0.3.0

data/test/unit/directive_link_to_test.rb

@@ -3,50 +3,65 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/link_to')
+#require File.join( currentPath, '../../lib/masterview/directives/link_to')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('link_to')
 
 class TestLinkTo < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
+  LinkTo = MasterView::Directives::LinkTo  # test subject
+
+  ELEMENT_TAG = 'a'
+
+  def test_metadata
+    assert_equal MasterView::ConfigSettings.namespace_prefix, LinkTo.namespace_prefix
+    assert_equal 'link_to', LinkTo.attribute_name
   end
 
   def test_default
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
+    link_tag = create_template_element ELEMENT_TAG, :content => 'Show Details'
     attr_value = ":action => 'show', :id => @product"
-    @directives << Link_to.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].content = "bar"
-    assert_equal "<%= link_to 'bar', :action => 'show', :id => @product %>", dcs.render
+    create_directive LinkTo, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= link_to( 'Show Details', :action => 'show', :id => @product ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_junk_name
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
-    attr_value = "'dont use', :action => 'show', :id => @product"
-    @directives << Link_to.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].content = "bar"
-    assert_equal "<%= link_to 'bar', :action => 'show', :id => @product %>", dcs.render
-  end
+    link_tag = create_template_element ELEMENT_TAG, :content => 'Show Details'
+    attr_value = "'do not use (ignored)', :action => 'show', :id => @product"
+    create_directive LinkTo, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= link_to( 'Show Details', :action => 'show', :id => @product ) %>"
+    assert_equal expected_content, render_element_event(:etag)
+    end
 
   def test_junk_plus
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
-    attr_value = "'dont use', 'nor this', :action => 'show', :id => @product"
-    @directives << Link_to.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].content = "bar"
-    assert_equal "<%= link_to 'bar', :action => 'show', :id => @product %>", dcs.render
+    link_tag = create_template_element ELEMENT_TAG, :content => 'Show Details'
+    attr_value = "'do not use (ignored)', :action => 'show', :id => @product"
+    create_directive LinkTo, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= link_to( 'Show Details', :action => 'show', :id => @product ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
+  def test_html
+    link_tag = create_template_element ELEMENT_TAG, :content => 'Show Details'
+    attr_value = ":action => 'show', {:id => @product}, :class => 'red'"
+    create_directive LinkTo, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= link_to( 'Show Details', :action => 'show', {:id => @product}, :class => 'red' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
+  end
+
+  def test_params
+    link_tag = create_template_element ELEMENT_TAG, :content => 'Show Details'
+    attr_value = ":action => 'show', {:id => @product}, {:class => 'red'}, 'foo', 1, 2"
+    create_directive LinkTo, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= link_to( 'Show Details', :action => 'show', {:id => @product}, {:class => 'red'}, 'foo', 1, 2 ) %>"
+    assert_equal expected_content, render_element_event(:etag)
+  end
 
 end

data/test/unit/directive_load_path_test.rb

@@ -0,0 +1,257 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/masterview/exceptions' )
+require File.join( currentPath, '../../lib/masterview/directive_metadata' )
+require File.join( currentPath, '../../lib/masterview/directive_load_path' )
+
+DEBUG_TRACE = false  #test dev hack
+
+class TestDirectiveLoadPath < Test::Unit::TestCase
+
+  CurrentPath = File.dirname(__FILE__)
+  MVTestDir = File.expand_path( File.join(CurrentPath, '..' ) )
+  TestFixturesDir = "#{MVTestDir}/fixtures"
+  TestDirectivesDir = "#{MVTestDir}/fixtures/directives"
+  MVInstallDir = File.expand_path( File.join(CurrentPath, '../../lib/masterview' ) )
+  BuiltinDirectivesDir = "#{MVInstallDir}/directives"
+
+  PathOptionsMasterviewDirectivesAbbrev = { :use_masterview_namespace => true }
+  PathOptionsMasterviewDirectivesFull = { :default => {:namespace => 'mv',}, :use_masterview_namespace => true }
+
+  PathOptionsExtensionsDirectivesAbbrev = { :default => { :namespace => 'mvx'}, }
+  PathOptionsExtensionsDirectivesFull = { :default => { :namespace => 'mvx'}, :use_masterview_namespace=>false }
+
+  # test subjects
+  PathEntry = MasterView::DirectiveLoadPath::PathEntry
+  Path = MasterView::DirectiveLoadPath::Path
+
+  SingletonValueClasses = [ Symbol, TrueClass, FalseClass, NilClass ]  # we don't care what options deep_copy did on these
+
+  def check_options_copy(original, copy)
+    assert_not_same original, copy, "Options copy not different: original=#{original.object_id}, copy=#{copy.object_id}"
+    original.each_pair { | key, originalValue |
+      copied_value = copy[key]
+      if originalValue.is_a?(Hash)
+        assert_not_same originalValue, copied_value, "Options copy not different for key #{key}: original=#{originalValue.object_id}, copy=#{copied_value.object_id}"
+        check_options_copy(originalValue, copied_value)
+      else
+        assert_equal originalValue, copied_value
+        if ! SingletonValueClasses.include?( originalValue.class)
+          assert_not_same originalValue, copied_value, "Options copy not different for key #{key}: original=#{originalValue.object_id}, copy=#{copied_value.object_id}"
+        end
+      end
+     }    
+  end
+
+  def check_path_copy(original, copy)
+    assert_not_same original, copy, "Path copy not different: original=#{original.object_id}, copy=#{copy.object_id}"  
+    original.each_index { | index |
+      dpe_original = original[index]
+      dpe_copy = copy[index]
+      assert_not_same dpe_original, dpe_copy
+      assert_equal dpe_original.dir_path, dpe_copy.dir_path, 'path dir should be equal'
+      assert_not_same dpe_original.dir_path, dpe_copy.dir_path, 'path dir should not be the same object'
+      check_options_copy(dpe_original.options, dpe_copy.options) 
+    }
+  
+  end
+
+  def test_path_entry_construction
+
+    STDOUT.puts "\n------- test_path_entry  --------" if DEBUG_TRACE
+
+    dir_path = BuiltinDirectivesDir
+    dpe = PathEntry.new(dir_path)
+    STDOUT.puts "...#{dpe.inspect}" if DEBUG_TRACE
+    assert_equal BuiltinDirectivesDir, dpe.dir_path
+    assert dpe.options.empty?, 'Default is empty options'
+    assert ! dpe.use_masterview_namespace, 'Only builtin MV directives use mv: namespace'
+    assert dpe.use_extensions_namespace, 'Addond MV directives use mvx: namespace by default'
+    assert dpe.metadata_defaults.empty?, 'Default is empty metadata defaults'
+
+    options = PathOptionsMasterviewDirectivesAbbrev
+    dpe = PathEntry.new(dir_path, options)
+    STDOUT.puts "...#{dpe.inspect}" if DEBUG_TRACE
+    assert_equal options.size, dpe.options.size
+    check_options_copy( options, dpe.options ) # 'PathEntry should always keep its own copy of options'
+    assert dpe.use_masterview_namespace, 'Builtin MV directives use mv: namespace'
+
+    dir_path = 'foo'
+    options = {:default=>{}, }
+    dpe = PathEntry.new(dir_path, options)
+    STDOUT.puts "...#{dpe.inspect}" if DEBUG_TRACE
+    assert_equal dir_path, dpe.dir_path
+    assert_equal options.size, dpe.options.size
+    check_options_copy( options, dpe.options ) # 'PathEntry should always keep its own copy of options'
+    assert ! dpe.use_masterview_namespace, 'Only builtin MV directives use mv: namespace'
+    assert dpe.use_extensions_namespace, 'Addond MV directives use mvx: namespace by default'
+    assert dpe.metadata_defaults.empty?, 'Default is empty metadata defaults'
+
+    dir_path = TestDirectivesDir
+    options = {:default=>{ :namespace => 'mvx'},:use_masterview_namespace=>false }
+    dpe = PathEntry.new(dir_path, options)
+    STDOUT.puts "...#{dpe.inspect}" if DEBUG_TRACE
+    assert_equal dir_path, dpe.dir_path
+    assert_equal options.size, dpe.options.size
+    check_options_copy( options, dpe.options ) # 'PathEntry should always keep its own copy of options'
+    assert ! dpe.use_masterview_namespace, 'Only builtin MV directives use mv: namespace'
+    assert dpe.use_extensions_namespace, 'Addon MV directives use mvx: namespace by default'
+    assert_equal 1, dpe.metadata_defaults.size, "Unexpected metadata defaults: #{dpe.options.inspect}"
+
+  end
+
+  def test_path_entry_validation
+
+    STDOUT.puts "\n------- test_path_entry_validation  --------" if DEBUG_TRACE
+
+    dir_path = BuiltinDirectivesDir
+    dpe = PathEntry.new(dir_path)
+    dpe.validate
+
+    dir_path = 'foo'
+    dpe = PathEntry.new(dir_path)
+
+    #assert_raise( MasterView::InvalidPathError ) { dpe.validate } #, 'Nonexistent path should cause error'
+    assert_raise( MasterView::InvalidDirectivePathError ) { dpe.validate } #, 'Nonexistent path should cause error'
+
+    begin
+      dpe.validate
+    rescue MasterView::InvalidDirectivePathError => ex
+      assert_same dpe.dir_path, ex.path  # MasterView::InvalidPathError info
+      assert_same dpe, ex.path_entry     # MasterView::InvalidDirectivePathError info
+      assert_not_nil ex.message
+    end
+
+  end
+
+  def test_path_entry_copy
+
+    STDOUT.puts "\n------- test_path_entry_copy  --------" if DEBUG_TRACE
+
+    dir_path = 'foo'
+    options = { 
+      :default => { :namespace => 'mvx', :description => 'TEST'}, 
+      :use_masterview_namespace=>false }
+
+    dpe = PathEntry.new(dir_path, options)
+    copy = dpe.deep_copy
+    assert_not_same dpe, copy
+    check_options_copy( options, dpe.options ) # 'PathEntry should always keep its own copy of options'
+    check_options_copy( options, copy.options )  # not what we started with
+    check_options_copy( dpe.options, copy.options )  # and not the copied guy
+
+    #test the test checker itself - verify that the checker detects non-copies
+    assert_raise( Test::Unit::AssertionFailedError ) { check_options_copy( options, options) }
+    # verify that un-doing the nested copy gets caught
+    copy.options[:default] =  dpe.options[:default]
+    assert_raise( Test::Unit::AssertionFailedError ) { check_options_copy( copy.options, dpe.options ) }
+
+  end
+
+  def test_path_ops
+
+    STDOUT.puts "\n------- test_path_ops  --------" if DEBUG_TRACE
+
+    path = Path.new
+    dir_paths = []
+
+    assert path.empty?
+    assert_equal 0, path.size
+
+    # verify that we can append a PathEntry
+    dir_path1 = 'foo'
+    dir_paths << dir_path1
+    dpe1 = PathEntry.new(dir_path1)
+    path << dpe1
+    assert_equal dir_paths.size, path.size
+    assert_same dpe1, path[0]
+
+    # verify that we can append a string
+    dir_path2 = 'bar'
+    dir_paths << dir_path2
+    path << dir_path2
+    assert_equal dir_paths.size, path.size
+    assert_equal dir_path2, path[-1].dir_path
+
+    # verify obscure compat support that probably never left Deb's machine
+    dir_path3 = 'wingding'
+    options3 = { :default => { :namespace => 'test' } }
+    dir_paths << dir_path3
+    path << [dir_path3, options3]
+    assert_equal dir_paths.size, path.size
+    assert_equal dir_path3, path[-1].dir_path
+    assert_equal options3, path[-1].options
+    assert_not_same options3, path[-1].options
+
+    # verify enumerating
+    count = 0
+    path.each { | dpe | 
+      assert dir_paths.include?( dpe.dir_path )
+      dpe.normalize  # set this up for the following test
+      count += 1 
+    }
+    assert_equal dir_paths.size, count
+
+    # we did normalization on the entries in the preceding
+    assert path.include?(path[-1].dir_path), 'Expanded path should be found'
+    assert path.include?(dir_path3), 'Original rel path should also be matched'
+
+    # verify (deep) copy
+    path_copy = path.copy
+    check_path_copy(path, path_copy)
+
+  end
+
+  def test_path_registry
+
+    STDOUT.puts "\n------- test_path_registry  --------" if DEBUG_TRACE
+
+    # normal sequence is for client app to append entries, then MV::Initializer cleans up
+    path = Path.new
+    path << PathEntry.new(BuiltinDirectivesDir, PathOptionsMasterviewDirectivesAbbrev)
+    path[-1].validate  # this is a legit entry
+    path << PathEntry.new('bar')
+    assert_raise( MasterView::InvalidDirectivePathError ) { path[1].validate } #, 'Nonexistent path should cause error'
+
+    # oh, just give up - this works standalone, but screws up the system state when we run entire suite
+    if true
+      return
+    end
+
+    # Masterview::Initializer cleans up the path, validates and normalizes, and registers
+    # But if we run this during test suite execution we don't know the state of the system, so be careful here
+    real_load_path_values = MasterView::DirectiveLoadPath.path_registry
+    if ! real_load_path_values.empty?
+      assert real_load_path_values.include?(:default)  # the default_load_path specs
+      assert real_load_path_values.include?(:current)  # the current load path
+    end
+    STDOUT.puts "...DirectiveLoadPath.default_path_specs=#{MasterView::DirectiveLoadPath.default_path_specs.inspect}" if DEBUG_TRACE
+    #assert_nil MasterView::DirectiveLoadPath.default_path_specs, 'this is what we'd expect at initial load time'
+    STDOUT.puts "...DirectiveLoadPath.current=#{MasterView::DirectiveLoadPath.current.inspect}" if DEBUG_TRACE
+    #assert_nil MasterView::DirectiveLoadPath.current
+    begin
+
+      MasterView::DirectiveLoadPath.default_path_specs = path
+      STDOUT.puts "...DirectiveLoadPath.default_path_specs=#{MasterView::DirectiveLoadPath.default_path_specs.object_id}" if DEBUG_TRACE
+      STDOUT.puts "...DirectiveLoadPath.current=#{MasterView::DirectiveLoadPath.current.object_id}" if DEBUG_TRACE
+
+      STDOUT.puts "...DirectiveLoadPath.default_path_specs=#{MasterView::DirectiveLoadPath.default_path_specs.inspect}" if DEBUG_TRACE
+      assert_not_nil MasterView::DirectiveLoadPath.default_path_specs
+      assert_not_same path, MasterView::DirectiveLoadPath.default_path_specs
+      STDOUT.puts "...DirectiveLoadPath.current=#{MasterView::DirectiveLoadPath.current.inspect}" if DEBUG_TRACE
+      assert_not_nil MasterView::DirectiveLoadPath.current
+      assert_not_same path, MasterView::DirectiveLoadPath.current
+      assert_not_same MasterView::DirectiveLoadPath.current, MasterView::DirectiveLoadPath.default_path_specs
+
+    ensure
+      # make sure we put the system back into whatever state it was in
+      real_load_path_values.each_pair { | key, real_value |
+          MasterView::DirectiveLoadPath.path_registry[key] = real_value
+      }
+    end
+
+  end
+
+end

data/test/unit/directive_metadata_test.rb

@@ -0,0 +1,313 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/masterview' )
+
+DEBUG_TRACE = false
+
+# test on correctness of managing separate metadata_values map for each class
+MetadataValuesIdentityMap = {}  # directive_class => directive_class.metadata_values.object_id
+def record_metadata_values_var(directive_class)
+  MetadataValuesIdentityMap[directive_class] = directive_class.metadata_values.object_id
+end
+
+module MasterView
+  module DirectiveMetadataTests
+
+    # directive implementation with simple class name
+    class Test1
+      include MasterView::DirectiveMetadata
+    end
+    record_metadata_values_var(Test1)
+
+if DEBUG_TRACE ### DEBUG ###
+STDOUT.puts "\n------- Directive test fixture class Test1 -------"
+STDOUT.puts "Instance variables: #{Test1.instance_variables}"
+STDOUT.puts "Instance methods: #{Test1.instance_methods(include_super=false).inspect}"
+STDOUT.puts "Class variables: #{Test1.class_variables}"
+#STDOUT.puts "Class methods: #{Test1.class.instance_methods(include_super=false).inspect}"
+foo = Test1.new
+STDOUT.puts "foo=#{foo.inspect}"
+STDOUT.puts "foo.instance_variables=#{foo.instance_variables.inspect}"
+STDOUT.puts "foo.class.class_variables=#{foo.class.class_variables.inspect}"
+STDOUT.puts "Test1.metadata_values=#{Test1.metadata_values.inspect} (id=#{Test1.metadata_values.object_id})"
+class Test1
+    STDOUT.puts "Test1 @@metadata_values=#{class_variable_get(:@@metadata_values).inspect} (id=#{class_variable_get(:@@metadata_values).object_id})"
+end
+STDOUT.puts "----------------------------------\n"
+end ### END DEBUG ###
+
+    # directive implementation with complex class name
+    class TestFoo
+      include MasterView::DirectiveMetadata
+    end
+    record_metadata_values_var(TestFoo)
+
+if DEBUG_TRACE ### DEBUG ###
+STDOUT.puts "\n------- Directive test fixture class TestFoo -------"
+STDOUT.puts "Instance variables: #{TestFoo.instance_variables}"
+STDOUT.puts "Instance methods: #{TestFoo.instance_methods(include_super=false).inspect}"
+STDOUT.puts "Class variables: #{TestFoo.class_variables}"
+#STDOUT.puts "Class methods: #{TestFoo.class.instance_methods(include_super=false).inspect}"
+foo = TestFoo.new
+STDOUT.puts "foo=#{foo.inspect}"
+STDOUT.puts "foo.instance_variables=#{foo.instance_variables.inspect}"
+STDOUT.puts "foo.class.class_variables=#{foo.class.class_variables.inspect}"
+STDOUT.puts "TestFoo.metadata_values=#{TestFoo.metadata_values.inspect} (id=#{TestFoo.metadata_values.object_id})"
+class TestFoo
+    STDOUT.puts "TestFoo @@metadata_values=#{class_variable_get(:@@metadata_values).inspect} (id=#{class_variable_get(:@@metadata_values).object_id})"
+end
+STDOUT.puts "----------------------------------\n"
+end ### END DEBUG ###
+
+    class Test3
+      include MasterView::DirectiveMetadata
+    end
+    record_metadata_values_var(Test3)
+
+    class Test4
+      include MasterView::DirectiveMetadata
+      STDOUT.puts "\n####LOADING #{self.name} DIRECTIVE TEST FIXTURE" if DEBUG_TRACE
+      metadata :attribute_name => 'test4zz', :namespace => 'mvzz', 
+        :description => 'test directive',
+        :priority => MasterView::DirectiveMetadata::DirectivePriorities::High
+      STDOUT.puts "...metadata_values: #{metadata_values.inspect}\n" if DEBUG_TRACE
+    end
+    record_metadata_values_var(Test4)
+
+    # test setting priority in various forms
+    class Test5
+      include MasterView::DirectiveMetadata 
+    end
+    record_metadata_values_var(Test5)
+
+  end
+end
+
+class TestDirectiveMetadata < Test::Unit::TestCase
+
+  include MasterView::DirectiveMetadataTests  # test fixtures
+
+  DirectiveMetadata = MasterView::DirectiveMetadata #test subject
+  DirectivePriorities = MasterView::DirectiveMetadata::DirectivePriorities
+
+  DefaultDirectivePriority = DirectivePriorities::Default
+
+  # we expect our test cases to belong in the mvx namespace
+  DefaultNamespacePrefix = MasterView::ConfigSettings.namespace_prefix_extensions
+
+  def check_standard_metadata(directive_class, directive, expected_ns_prefix=DefaultNamespacePrefix)
+    expected_ns = expected_ns_prefix[0...-1]
+    expected_attr_name = directive_class.default_directive_name
+    expected_qname = "#{expected_ns}:#{expected_attr_name}"
+    assert_equal expected_ns_prefix, directive_class.default_namespace_prefix, "Bad #{directive_class.name}.default_namespace_prefix"
+    [ directive_class, directive ].each { | testSubject |
+      STDOUT.puts "##CHECKING #{testSubject}" if DEBUG_TRACE
+      assert_equal expected_attr_name, testSubject.attribute_name, "#{testSubject.inspect} metadata problem (attr name)"
+      assert_equal expected_ns_prefix, testSubject.namespace_prefix, "#{testSubject.inspect} metadata problem (ns_prefix)"
+      assert_equal expected_ns, testSubject.namespace_name, "#{testSubject.inspect} metadata problem (ns_name)"
+      assert_equal expected_qname, testSubject.attribute_qname, "#{testSubject.inspect} metadata problem (attr qname)"
+      assert_equal "#{testSubject.namespace}:#{testSubject.attribute_name}", testSubject.attribute_qname, "#{testSubject.inspect} metadata problem (attr qname)"      
+      assert_equal "#{testSubject.namespace_prefix}#{testSubject.attribute_name}", testSubject.attribute_qname, "#{testSubject.inspect} metadata problem (attr qname)"
+      assert_equal DefaultDirectivePriority, testSubject.priority, "#{testSubject.inspect} metadata problem (priority)"
+    }
+    assert_equal DirectivePriorities::Medium, DirectivePriorities::Default
+  end
+
+  def check_metadata_values_var(directive_class)
+    expected_obj_id = MetadataValuesIdentityMap[directive_class]
+    actual_obj_id = directive_class.metadata_values.object_id
+    msg = "#{directive_class.name}.metadata_values=#{directive_class.metadata_values.inspect} (id=#{actual_obj_id})"
+    STDOUT.puts msg if DEBUG_TRACE
+    assert_equal expected_obj_id, actual_obj_id, msg
+  end
+
+  def check_required_metadata_props_defined(directive_class)
+    expected_props = Set.new.merge DirectiveMetadata::HARDENED_PROPERTY_NAMES
+    actual_props = Set.new.merge directive_class.metadata_values.keys
+    assert_equal expected_props, actual_props
+  end
+
+  def test_directive_test1
+
+    directive_class = Test1
+    directive = directive_class.new
+
+    assert_equal 'test1', directive_class.default_directive_name
+    check_metadata_values_var(directive_class)
+
+    assert directive_class.metadata_values.empty?   
+    check_standard_metadata(directive_class, directive)
+
+    directive_class.harden_metadata
+    check_required_metadata_props_defined(directive_class)
+    check_standard_metadata(directive_class, directive)
+
+  end
+
+  def test_directive_test_foo
+
+    directive_class = TestFoo
+    directive = directive_class.new
+
+    assert_equal 'test_foo', directive_class.default_directive_name, 'observe CamelCase -> snake_case'
+    check_metadata_values_var(directive_class)
+
+    assert directive_class.metadata_values.empty?
+    check_standard_metadata(directive_class, directive)
+
+    directive_class.harden_metadata
+    check_required_metadata_props_defined(directive_class)
+    check_standard_metadata(directive_class, directive)
+
+  end
+
+  def test_set_explicit_metadata
+
+    directive_class = Test3
+    directive = directive_class.new
+
+    assert_equal 'test3', directive_class.default_directive_name
+    check_metadata_values_var(directive_class)
+
+    assert directive_class.metadata_values.empty?
+    check_standard_metadata(directive_class, directive)
+
+    attr_name = 'test3xx'
+    default_namespace_prefix = DefaultNamespacePrefix
+    md_specs = "metadata :attribute_name => '#{attr_name}'"
+    directive_class.class_eval md_specs
+    check_metadata_values_var(directive_class)
+    assert_equal attr_name, directive_class.attribute_name
+    assert attr_name != directive_class.default_directive_name
+    assert_equal directive_class.attribute_qname, "#{default_namespace_prefix}#{attr_name}" 
+
+    ns_name = 'mvx'
+    md_specs = "metadata :namespace => '#{ns_name}'"
+    directive_class.class_eval md_specs
+    check_metadata_values_var(directive_class)
+    assert_equal ns_name, directive_class.namespace_name
+    assert_equal "#{ns_name}:", directive_class.namespace_prefix, 'automatically synched with ns change'
+    assert_equal "#{ns_name}:#{directive_class.default_directive_name}", directive_class.attribute_qname 
+
+    attr_name = 'test3yy'
+    ns_name = 'mvy'
+    md_specs = "metadata :attribute_name => '#{attr_name}', :namespace => '#{ns_name}'"
+    directive_class.class_eval md_specs
+    check_metadata_values_var(directive_class)
+    assert_equal attr_name, directive_class.attribute_name
+    assert attr_name != directive_class.default_directive_name
+    assert_equal ns_name, directive_class.namespace_name
+    assert_equal "#{ns_name}:", directive_class.namespace_prefix, 'automatically synched with ns change'
+    assert_equal "#{ns_name}:#{attr_name}", directive_class.attribute_qname 
+
+  end
+
+  def test_declared_metadata
+
+    directive_class = Test4
+    directive = directive_class.new
+
+    attr_name = 'test4zz'
+    ns_name = 'mvzz'
+    
+    assert_equal 'test4', directive_class.default_directive_name
+    check_metadata_values_var(directive_class)
+
+    assert ! directive_class.metadata_values.empty?
+    assert_equal attr_name, directive_class.attribute_name
+    assert attr_name != directive_class.default_directive_name
+    assert_equal ns_name, directive_class.namespace_name
+    assert_equal "#{ns_name}:", directive_class.namespace_prefix, 'automatically synched with ns change'
+    assert_equal "#{ns_name}:#{attr_name}", directive_class.attribute_qname 
+
+    assert_not_nil directive_class.metadata_values[:description]
+    assert DefaultDirectivePriority != directive_class.priority
+    assert_equal DirectivePriorities::High, directive_class.priority
+
+  end
+
+  def test_validation_checking
+
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'foo' }
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'foo-bar' }
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'foo_bar' }
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'foo99' }
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'Foo' }
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'FooBar' }
+
+    ###TODO: need to install checking for illegal ids per xml name syntax
+    #assert_raise( ArgumentError ) { DirectiveMetadata.validate_xml_identifier 'foo bar' }
+    assert_nothing_raised { DirectiveMetadata.validate_xml_identifier 'foo bar' }
+
+  end
+
+  def test_consistency_checking
+
+    md_props = { :namespace => 'foo' }
+    DirectiveMetadata.validate_metadata_props! md_props
+    assert_equal 2, md_props.size, ':namespace_prefix added'
+    assert_equal 'foo:', md_props[:namespace_prefix]
+
+    md_props = { :namespace_name => 'foo' }  # synonym, use should be discouraged
+    DirectiveMetadata.validate_metadata_props! md_props
+    assert_equal 2, md_props.size, ':namespace_prefix added'
+    assert_equal 'foo:', md_props[:namespace_prefix]
+
+    md_props = { :namespace_prefix => 'bar:' }
+    DirectiveMetadata.validate_metadata_props! md_props
+    assert_equal 2, md_props.size, ':namespace added'
+    assert_equal 'bar', md_props[:namespace]
+    assert_equal 'bar:', md_props[:namespace_prefix]
+
+  end
+
+  def test_priority_services
+    DirectiveMetadata::PriorityNames.each{ | level_name | 
+      priority = DirectivePriorities.const_get(level_name)
+      assert_equal level_name, DirectiveMetadata.get_priority_name(priority)
+    }
+  end
+
+  def test_priority
+
+    directive_class = Test5
+
+    check_metadata_values_var(directive_class)
+
+    assert_equal DirectivePriorities::Medium, DirectivePriorities::Default
+
+    assert_equal DefaultDirectivePriority, directive_class.priority
+
+    directive_class.metadata :priority => DirectivePriorities::Lowest
+    assert_equal DirectivePriorities::Lowest, directive_class.priority
+
+    directive_class.metadata :priority => 'VeryLow'
+    assert_equal DirectivePriorities::VeryLow, directive_class.priority
+
+    directive_class.metadata :priority => :VeryHigh
+    assert_equal DirectivePriorities::VeryHigh, directive_class.priority
+
+    directive_class.metadata :priority => 'Highest'
+    assert_equal DirectivePriorities::Highest, directive_class.priority
+
+    # check the synonyms
+    [ 'Default', 'default', :default ].each { |level_name|
+      # first set the value to a known state
+      directive_class.metadata :priority => 'Highest'
+      assert_equal DirectivePriorities::Highest, directive_class.priority    
+      # now verify that all the synonyms for default priority level work
+      directive_class.metadata :priority => level_name
+      assert_equal DirectivePriorities::Default, directive_class.priority    
+    }
+    
+    # error conditions
+    assert_raise( ArgumentError ) { directive_class.metadata :priority => -1 }
+    assert_raise( ArgumentError ) { directive_class.metadata :priority => DirectivePriorities::Lowest + 1 }
+    assert_raise( ArgumentError ) { directive_class.metadata :priority => 'nonesuch' }
+    assert_raise( ArgumentError ) { directive_class.metadata :priority => nil }
+
+  end
+
+end