masterview 0.2.5 → 0.3.0

data/test/unit/directive_base_test.rb

@@ -3,8 +3,160 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
+require File.join( currentPath, '../test_helper' )
+
+class DirectiveExample < MasterView::DirectiveBase
+  attr_arg :obj, :quote => true
+  attr_arg(:method) { 'override' }
+  attr_arg(:foo) { |x| x.downcase }
+  attr_arg :collection, :quote => true
+  attr_arg :value_method, :quote => true
+  attr_arg :text_method, :quote => true
+  attr_arg :options, :default => {}
+  attr_arg :html_options, :append_element_attrs => [:common_html, :onclick]
+
+  event :before_stag do
+    render erb_content( 'text_area', :obj, :method, :foo )
+  end
+
+  event :after_stag, :foo => :bar do
+    render :nothing
+  end
+
+  event :content, :render => :nothing #rolls up all content between after_stag and before_etag
+
+  event :stag do
+    # unless render something or render :nothing is called, then dcs.render will still occur implicitely
+  end
+
+  event :etag do
+    con = render_result() # get the dcs.render result so we can modify it
+    con.gsub!( /foo/, 'bar' )
+    render con
+  end
+
+  event :element do # this will allow replacement of entire element and children
+    render erb_eval( 'execute something' )
+  end
+end
+
+class DirectiveExampleNoStag < MasterView::DirectiveBase
+  event :before_stag do
+    render 'foo'
+  end
+
+  event :after_etag, :render => :nothing
+end
+
+class DirectiveExampleRenderNothingOption < MasterView::DirectiveBase
+  event :before_stag do
+    render 'foo'
+  end
+
+  event :stag, :render => :nothing
+
+  event :etag, :render => :nothing do
+    render 'this should not be rendered'
+  end
+end
+
+class DirectiveExampleRenderNothingContent < MasterView::DirectiveBase
+  event :stag do
+    self.content = 'this is content, but will not be rendered'
+    render 'foo'
+  end
+
+  event :content, :render => :nothing
+
+  event :etag do
+    render 'bar'
+  end
+end
+
+class DirectiveExampleRenderNothingElement < MasterView::DirectiveBase
+  event :stag do
+    self.content = 'this is content, but will not be rendered'
+    render 'foo'
+  end
+
+  event :etag do
+    render 'bar'
+  end
+
+  event :element, :render => :nothing
+end
+
+class DirectiveExampleRenderNothingMethod < MasterView::DirectiveBase
+  event :stag do
+    render 'this will be cancelled out by :nothing call'
+    render :nothing
+  end
+end
+
+class DirectiveExampleParamsArray < MasterView::DirectiveBase
+  attr_arg :obj
+  attr_arg :params, :varargs => true
+
+  event :stag do
+    render erb_content( 'foo', :obj, :params )
+  end
+end
+
+class DirectiveExampleNonhashFirstString < MasterView::DirectiveBase
+  attr_arg :name do |value, args|
+    if value.respond_to?(:include?) and value.include?('=>')
+      args.unshift value
+      nil
+    else
+      value
+    end
+  end
+
+  attr_arg :options
+end
+
+
+class DirectiveExampleInst < MasterView::DirectiveBase
+  attr_arg :name do |value, args, inst|
+    if value.respond_to?(:include?) and value.include?('=>')
+      args.unshift value
+      inst.quote(inst.element_attrs[:foo])
+    else
+      value
+    end
+  end
+
+  attr_arg :options
+
+  event :etag do
+    render erb_content( 'test', :name, :options )
+  end
+
+end
+
+class DirectiveWithChild < MasterView::DirectiveBase
+  event :before_child_td_stag do
+  end
+
+  event :child_any_etag do
+  end
+
+  event :descendant_th_content do
+  end
+
+  event :after_descendant_th_etag do
+  end
+
+  event :descendant_th_etag do
+  end
+end
+
+class TestDirectiveBaseNew < Test::Unit::TestCase
+
+  # shortcut refs for internal DirectiveDSL implementation classes
+  EventDef = MasterView::DirectiveProcessing::EventDef
+  RenderAccumulator = MasterView::DirectiveProcessing::RenderAccumulator
 
-class TestDirectiveBase < Test::Unit::TestCase
   def setup
     @base = MasterView::DirectiveBase.new('')
   end
@@ -13,6 +165,10 @@ class TestDirectiveBase < Test::Unit::TestCase
     assert_equal '\'hello\'', @base.quote('hello')
   end
 
+  def test_quote_double
+    assert_equal '"hello"', @base.quote('hello', '"')
+  end
+
   def test_quote_if
     assert_equal '\'helloWorld0123\'', @base.quote_if('helloWorld0123')
     assert_equal 'hello world', @base.quote_if('hello world')
@@ -26,4 +182,367 @@ class TestDirectiveBase < Test::Unit::TestCase
     assert_equal '\'\'', @base.quote_if('')
   end
 
+  def test_event_def_valid_mappings
+    assert EventDef.valid_event_mapping?( :before_stag )
+    assert EventDef.valid_event_mapping?( :stag )
+    assert EventDef.valid_event_mapping?( :after_stag )
+    assert EventDef.valid_event_mapping?( :content )
+    assert EventDef.valid_event_mapping?( :before_etag )
+    assert EventDef.valid_event_mapping?( :etag )
+    assert EventDef.valid_event_mapping?( :after_etag )
+    assert EventDef.valid_event_mapping?( :element )
+
+    assert EventDef.valid_event_mapping?( :before_child_td_stag )
+    assert EventDef.valid_event_mapping?( :child_td_stag )
+    assert EventDef.valid_event_mapping?( :after_child_td_stag )
+    assert EventDef.valid_event_mapping?( :child_td_content )
+    assert EventDef.valid_event_mapping?( :child_td_element )
+    assert EventDef.valid_event_mapping?( :before_child_any_stag )
+    assert EventDef.valid_event_mapping?( :child_any_stag )
+    assert EventDef.valid_event_mapping?( :after_child_any_stag )
+    assert EventDef.valid_event_mapping?( :child_any_content )
+    assert EventDef.valid_event_mapping?( :child_any_element )
+    assert EventDef.valid_event_mapping?( :before_child_tbody_td_stag )
+    assert EventDef.valid_event_mapping?( :child_tbody_td_stag )
+    assert EventDef.valid_event_mapping?( :after_child_tbody_td_stag )
+    assert EventDef.valid_event_mapping?( :child_tbody_td_content )
+    assert EventDef.valid_event_mapping?( :child_tbody_td_element )
+
+    assert EventDef.valid_event_mapping?( :before_descendant_td_stag )
+    assert EventDef.valid_event_mapping?( :descendant_td_stag )
+    assert EventDef.valid_event_mapping?( :after_descendant_td_stag )
+    assert EventDef.valid_event_mapping?( :descendant_td_content )
+    assert EventDef.valid_event_mapping?( :descendant_td_element )
+    assert EventDef.valid_event_mapping?( :before_descendant_any_stag )
+    assert EventDef.valid_event_mapping?( :descendant_any_stag )
+    assert EventDef.valid_event_mapping?( :after_descendant_any_stag )
+    assert EventDef.valid_event_mapping?( :descendant_any_content )
+    assert EventDef.valid_event_mapping?( :descendant_any_element )
+    assert EventDef.valid_event_mapping?( :before_descendant_tbody_td_stag )
+    assert EventDef.valid_event_mapping?( :descendant_tbody_td_stag )
+    assert EventDef.valid_event_mapping?( :after_descendant_tbody_td_stag )
+    assert EventDef.valid_event_mapping?( :descendant_tbody_td_content )
+    assert EventDef.valid_event_mapping?( :descendant_tbody_td_element )
+
+    assert !EventDef.valid_event_mapping?( :foo )
+    assert !EventDef.valid_event_mapping?( :child_bar )
+    assert !EventDef.valid_event_mapping?( :before_child_hello )
+  end
+
+  def test_event_def_base_method
+    assert_equal [:stag], EventDef.base_methods_from_event( :before_stag )
+    assert_equal [:stag], EventDef.base_methods_from_event( :stag )
+    assert_equal [:stag], EventDef.base_methods_from_event( :after_stag )
+    assert_equal [:etag], EventDef.base_methods_from_event( :content )
+    assert_equal [:etag], EventDef.base_methods_from_event( :before_etag )
+    assert_equal [:etag], EventDef.base_methods_from_event( :etag )
+    assert_equal [:etag], EventDef.base_methods_from_event( :after_etag )
+    assert_equal [:stag, :etag], EventDef.base_methods_from_event( :element )
+
+    assert_equal [:child_td_stag], EventDef.base_methods_from_event( :before_child_td_stag )
+    assert_equal [:child_td_stag], EventDef.base_methods_from_event( :child_td_stag )
+    assert_equal [:child_td_stag], EventDef.base_methods_from_event( :after_child_td_stag )
+    assert_equal [:child_td_etag], EventDef.base_methods_from_event( :child_td_content )
+    assert_equal [:child_td_stag, :child_td_etag], EventDef.base_methods_from_event( :child_td_element )
+    assert_equal [:child_any_stag], EventDef.base_methods_from_event( :before_child_any_stag )
+    assert_equal [:child_any_stag], EventDef.base_methods_from_event( :child_any_stag )
+    assert_equal [:child_any_stag], EventDef.base_methods_from_event( :after_child_any_stag )
+    assert_equal [:child_any_etag], EventDef.base_methods_from_event( :child_any_content )
+    assert_equal [:child_any_stag, :child_any_etag], EventDef.base_methods_from_event( :child_any_element )
+    assert_equal [:child_tbody_td_stag], EventDef.base_methods_from_event( :before_child_tbody_td_stag )
+    assert_equal [:child_tbody_td_stag], EventDef.base_methods_from_event( :child_tbody_td_stag )
+    assert_equal [:child_tbody_td_stag], EventDef.base_methods_from_event( :after_child_tbody_td_stag )
+    assert_equal [:child_tbody_td_etag], EventDef.base_methods_from_event( :child_tbody_td_content )
+    assert_equal [:child_tbody_td_stag, :child_tbody_td_etag], EventDef.base_methods_from_event( :child_tbody_td_element )
+
+    assert_equal [:descendant_td_stag], EventDef.base_methods_from_event( :before_descendant_td_stag )
+    assert_equal [:descendant_td_stag], EventDef.base_methods_from_event( :descendant_td_stag )
+    assert_equal [:descendant_td_stag], EventDef.base_methods_from_event( :after_descendant_td_stag )
+    assert_equal [:descendant_td_etag], EventDef.base_methods_from_event( :descendant_td_content )
+    assert_equal [:descendant_td_stag, :descendant_td_etag], EventDef.base_methods_from_event( :descendant_td_element )
+    assert_equal [:descendant_any_stag], EventDef.base_methods_from_event( :before_descendant_any_stag )
+    assert_equal [:descendant_any_stag], EventDef.base_methods_from_event( :descendant_any_stag )
+    assert_equal [:descendant_any_stag], EventDef.base_methods_from_event( :after_descendant_any_stag )
+    assert_equal [:descendant_any_etag], EventDef.base_methods_from_event( :descendant_any_content )
+    assert_equal [:descendant_any_stag, :descendant_any_etag], EventDef.base_methods_from_event( :descendant_any_element )
+    assert_equal [:descendant_tbody_td_stag], EventDef.base_methods_from_event( :before_descendant_tbody_td_stag )
+    assert_equal [:descendant_tbody_td_stag], EventDef.base_methods_from_event( :descendant_tbody_td_stag )
+    assert_equal [:descendant_tbody_td_stag], EventDef.base_methods_from_event( :after_descendant_tbody_td_stag )
+    assert_equal [:descendant_tbody_td_etag], EventDef.base_methods_from_event( :descendant_tbody_td_content )
+    assert_equal [:descendant_tbody_td_stag, :descendant_tbody_td_etag], EventDef.base_methods_from_event( :descendant_tbody_td_element )
+  end
+
+  def test_event_def_method_events_from_base
+    assert_equal [:before_stag, :stag, :after_stag], EventDef.method_events_from_base( :stag )
+    assert_equal [:before_child_td_stag, :child_td_stag, :after_child_td_stag], EventDef.method_events_from_base( :child_td_stag )
+    assert_equal [:before_child_any_stag, :child_any_stag, :after_child_any_stag], EventDef.method_events_from_base( :child_any_stag )
+    assert_equal [:before_child_tbody_td_stag, :child_tbody_td_stag, :after_child_tbody_td_stag], EventDef.method_events_from_base( :child_tbody_td_stag )
+    assert_equal [:before_descendant_td_stag, :descendant_td_stag, :after_descendant_td_stag], EventDef.method_events_from_base( :descendant_td_stag )
+    assert_equal [:before_descendant_tbody_td_stag, :descendant_tbody_td_stag, :after_descendant_tbody_td_stag], EventDef.method_events_from_base( :descendant_tbody_td_stag )
+
+    assert_equal [:content, :before_etag, :etag, :after_etag, :element], EventDef.method_events_from_base( :etag )
+    assert_equal [:child_tbody_td_content, :before_child_tbody_td_etag, :child_tbody_td_etag, :after_child_tbody_td_etag, :child_tbody_td_element], EventDef.method_events_from_base( :child_tbody_td_etag )
+    assert_equal [:descendant_td_content, :before_descendant_td_etag, :descendant_td_etag, :after_descendant_td_etag, :descendant_td_element], EventDef.method_events_from_base( :descendant_td_etag )
+    assert_equal [:descendant_tbody_td_content, :before_descendant_tbody_td_etag, :descendant_tbody_td_etag, :after_descendant_tbody_td_etag, :descendant_tbody_td_element], EventDef.method_events_from_base( :descendant_tbody_td_etag )
+  end
+
+
+    # return array of events to check for the base
+    #  :stag => [:before_stag, :stag, :after_stag],
+    #  :etag => [:content, :before_etag, :etag, :after_etag, :element]
+  #   def self.method_events_from_base(base_sym)
+#       base_str = base_sym.to_s
+#       case base_str
+#         when /(.*)stag/
+#         [
+#           ('before_'+base_str).to_sym,
+#           base_sym,
+#           ('after_'+base_str).to_sym
+#         ]
+#         when /(.*)etag/
+#         [
+#           ('\1content').to_sym,
+#           ('before_'+base_str).to_sym,
+#           base_sym,
+#           ('after_'+base_str).to_sym,
+#           ('\1element').to_sym
+#         ]
+#       end
+#     end
+
+
+
+  def test_attr_arg_defs
+    assert_equal 8, DirectiveExample.directive_class_def.attr_arg_defs.size
+    assert_equal :obj, DirectiveExample.directive_class_def.attr_arg_defs[0].name
+    assert_equal :method, DirectiveExample.directive_class_def.attr_arg_defs[1].name
+    assert_equal :foo, DirectiveExample.directive_class_def.attr_arg_defs[2].name
+    assert_equal :collection, DirectiveExample.directive_class_def.attr_arg_defs[3].name
+    assert_equal :value_method, DirectiveExample.directive_class_def.attr_arg_defs[4].name
+    assert_equal :text_method, DirectiveExample.directive_class_def.attr_arg_defs[5].name
+    assert_equal :options, DirectiveExample.directive_class_def.attr_arg_defs[6].name
+    assert_equal :html_options, DirectiveExample.directive_class_def.attr_arg_defs[7].name
+
+    assert_equal :obj, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:obj).name
+    assert_equal :method, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:method).name
+    assert_equal :foo, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:foo).name
+    assert_equal :collection, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:collection).name
+    assert_equal :value_method, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:value_method).name
+    assert_equal :text_method, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:text_method).name
+    assert_equal :options, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:options).name
+    assert_equal :html_options, DirectiveExample.directive_class_def.find_attr_arg_def_by_name(:html_options).name
+
+    assert_equal( { :quote => true }, DirectiveExample.directive_class_def.attr_arg_defs[0].options )
+    assert_equal( { }, DirectiveExample.directive_class_def.attr_arg_defs[1].options )
+    assert_equal( { }, DirectiveExample.directive_class_def.attr_arg_defs[2].options )
+    assert_equal( { :quote => true }, DirectiveExample.directive_class_def.attr_arg_defs[3].options )
+    assert_equal( { :quote => true }, DirectiveExample.directive_class_def.attr_arg_defs[4].options )
+    assert_equal( { :quote => true }, DirectiveExample.directive_class_def.attr_arg_defs[5].options )
+    assert_equal( { :default => {} }, DirectiveExample.directive_class_def.attr_arg_defs[6].options )
+    assert_equal( {}, DirectiveExample.directive_class_def.attr_arg_defs[6].optional_default )
+    assert_equal( { :append_element_attrs => [:common_html, :onclick] }, DirectiveExample.directive_class_def.attr_arg_defs[7].options )
+  end
+
+  def test_prepare_arg_instance_vars
+    d = DirectiveExample.new('product, desc, "Foo", coll, val, text, {:foo => :bar}, :readonly => false')
+    d.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    d.element_attrs['class'] = 'red'
+    d.element_attrs['id'] = 'id1'
+    d.element_attrs['onclick'] = 'jsfunc'
+    d.prepare_arg_instance_vars
+    assert_equal "'product'", d.instance_variable_get(:@obj)
+    assert_equal 'override', d.instance_variable_get(:@method)
+    assert_equal '"foo"', d.instance_variable_get(:@foo)
+    assert_equal "'coll'", d.instance_variable_get(:@collection)
+    assert_equal "'val'", d.instance_variable_get(:@value_method)
+    assert_equal "'text'", d.instance_variable_get(:@text_method)
+    assert_equal '{:foo => :bar}', d.instance_variable_get(:@options)
+    assert_equal ':readonly => false, :class => "red", :id => "id1", :onclick => "jsfunc"', d.instance_variable_get(:@html_options)
+  end
+
+  def test_params_array
+    d = DirectiveExampleParamsArray.new('product, desc, "Foo", coll, val, text, {:foo => :bar}, :readonly => false')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    d.prepare_arg_instance_vars
+    assert_equal "product", d.instance_variable_get(:@obj)
+    assert_equal ['desc', '"Foo"', 'coll', 'val', 'text', '{:foo => :bar}', ':readonly => false'], d.instance_variable_get(:@params)
+
+    d = DirectiveExampleParamsArray.new('product, desc, hello, world')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    assert_equal ['<%= foo( product, desc, hello, world ) %>'], d.stag(dcs)
+
+    d = DirectiveExampleParamsArray.new('product')
+    d.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    d.prepare_arg_instance_vars
+    assert_equal "product", d.instance_variable_get(:@obj)
+    assert_equal [], d.instance_variable_get(:@params)
+
+    d = DirectiveExampleParamsArray.new('product')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    assert_equal ['<%= foo( product ) %>'], d.stag(dcs)
+
+    d = DirectiveExampleParamsArray.new(":action => 'create'")
+    d.save_directive_call_stack(MasterView::ParserMock.createMockDCS())
+    d.prepare_arg_instance_vars
+    assert_equal ":action => 'create'", d.instance_variable_get(:@obj)
+  end
+
+  def test_nonhash_first_string
+    d = DirectiveExampleNonhashFirstString.new('foo, :bar => :baz')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    d.prepare_arg_instance_vars
+    assert_equal "foo", d.instance_variable_get(:@name)
+    assert_equal ":bar => :baz", d.instance_variable_get(:@options)
+
+    d = DirectiveExampleNonhashFirstString.new(':bar => :baz')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    d.prepare_arg_instance_vars
+    assert_nil d.instance_variable_get(:@name)
+    assert_equal ":bar => :baz", d.instance_variable_get(:@options)
+  end
+
+  def test_inst
+    d = DirectiveExampleInst.new(':bar => :baz')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    d.element_attrs[:foo] = 'hello'
+    d.prepare_arg_instance_vars
+    assert_equal "'hello'", d.instance_variable_get(:@name)
+    assert_equal ":bar => :baz", d.instance_variable_get(:@options)
+  end
+
+  def test_event_defs
+    assert_equal 6, DirectiveExample.directive_class_def.event_defs.size
+    assert DirectiveExample.directive_class_def.event_defs[:before_stag]
+    assert DirectiveExample.directive_class_def.event_defs[:after_stag]
+    assert DirectiveExample.directive_class_def.event_defs[:stag]
+    assert DirectiveExample.directive_class_def.event_defs[:content]
+    assert DirectiveExample.directive_class_def.event_defs[:etag]
+    assert DirectiveExample.directive_class_def.event_defs[:element]
+    assert !DirectiveExample.directive_class_def.event_defs[:doesnt_exist]
+
+    assert_equal( {}, DirectiveExample.directive_class_def.event_defs[:before_stag].options )
+    assert_equal( {:foo => :bar}, DirectiveExample.directive_class_def.event_defs[:after_stag].options )
+    assert_equal( {}, DirectiveExample.directive_class_def.event_defs[:stag].options )
+    assert_equal( { :render => :nothing }, DirectiveExample.directive_class_def.event_defs[:content].options )
+    assert_equal( {}, DirectiveExample.directive_class_def.event_defs[:etag].options )
+    assert_equal( {}, DirectiveExample.directive_class_def.event_defs[:element].options )
+  end
+
+  def test_methods_defined
+    assert DirectiveExample.public_method_defined?(:stag)
+    assert DirectiveExample.public_method_defined?(:etag)
+    assert !DirectiveExample.public_method_defined?(:before_stag)
+    assert !DirectiveExample.public_method_defined?(:after_stag)
+  end
+
+  def test_render_accumulator
+    ra = RenderAccumulator.new
+    assert_equal [], ra.method_level_content_array
+    assert_equal [], ra.event_level_content_array
+    assert_equal false, ra.render_call_found
+    assert_nil ra.instance_variable_get(:@render_result)
+    assert_nil ra.instance_variable_get(:@render_result_block)
+
+    ra.add_to_event_content 'foo'
+    assert_equal [], ra.method_level_content_array
+    assert_equal ['foo'], ra.event_level_content_array
+    assert_equal true, ra.render_call_found
+
+    ra.add_to_event_content 'bar'
+    assert_equal [], ra.method_level_content_array
+    assert_equal ['foo', 'bar'], ra.event_level_content_array
+    assert_equal true, ra.render_call_found
+
+    ra.add_event_content_to_method_content
+    assert_equal ['foo', 'bar'], ra.method_level_content_array
+    assert_equal [], ra.event_level_content_array
+    assert_equal true, ra.render_call_found
+
+    ra.add_to_event_content 'hello'
+    ra.replace_all_method_content_with_event_content
+    assert_equal ['hello'], ra.method_level_content_array
+
+    ra.add_to_event_content 'hello'
+    ra.reset_event_level_vars
+    assert_equal [], ra.event_level_content_array
+    assert_equal false, ra.render_call_found
+    assert_nil ra.instance_variable_get(:@render_result)
+    assert_nil ra.instance_variable_get(:@render_result_block)
+
+    ra.render_result_block = lambda { ra.render_result = 'wow' }
+    assert_equal 'wow', ra.call_render_result_block
+    assert_equal 'wow', ra.instance_variable_get(:@render_result)
+    ra.render_result = 'changed'
+    assert_nil ra.instance_variable_get(:@render_result_block)
+    assert_equal 'changed', ra.instance_variable_get(:@render_result)
+  end
+
+  def test_no_stag
+    assert DirectiveExampleNoStag.public_method_defined?(:stag)
+    assert DirectiveExampleNoStag.public_method_defined?(:etag)
+  end
+
+  def test_event_defs_no_stag
+    assert_equal 4, DirectiveExampleNoStag.directive_class_def.event_defs.size
+    assert DirectiveExampleNoStag.directive_class_def.event_defs[:before_stag]
+    assert DirectiveExampleNoStag.directive_class_def.event_defs[:after_etag]
+    assert DirectiveExampleNoStag.directive_class_def.event_defs[:stag]
+    assert DirectiveExampleNoStag.directive_class_def.event_defs[:etag]
+  end
+
+  def test_nothing_option
+    d = DirectiveExampleRenderNothingOption.new('')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    assert_equal ['foo'], d.stag(dcs)
+    assert_equal [], d.etag(dcs)
+  end
+
+  def test_nothing_option_content
+    d = DirectiveExampleRenderNothingContent.new('')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    d.etag(dcs)
+    assert_equal nil, dcs.content
+  end
+
+  def test_nothing_option_element
+    d = DirectiveExampleRenderNothingElement.new('')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    assert_equal ['foo'], d.stag(dcs)
+    assert_equal [], d.etag(dcs)
+    assert_equal nil, dcs.content
+    assert_equal nil, dcs.stag
+  end
+
+  def test_nothing_method
+    d = DirectiveExampleRenderNothingMethod.new('')
+    dcs = MasterView::ParserMock.createMockDCS()
+    d.save_directive_call_stack(dcs)
+    assert_equal [], d.stag(dcs)
+  end
+
+  def test_event_defs_for_child
+    assert_equal 6, DirectiveWithChild.directive_class_def.event_defs.size
+    assert DirectiveWithChild.directive_class_def.event_defs[:before_child_td_stag]
+    assert DirectiveWithChild.directive_class_def.event_defs[:child_td_stag]
+    assert DirectiveWithChild.directive_class_def.event_defs[:child_any_etag]
+    assert DirectiveWithChild.directive_class_def.event_defs[:descendant_th_content]
+    assert DirectiveWithChild.directive_class_def.event_defs[:after_descendant_th_etag]
+    assert DirectiveWithChild.directive_class_def.event_defs[:descendant_th_etag]
+    assert DirectiveWithChild.public_method_defined?(:child_td_stag)
+    assert DirectiveWithChild.public_method_defined?(:child_any_etag)
+    assert DirectiveWithChild.public_method_defined?(:descendant_th_etag)
+  end
+
+
+
+
 end

data/test/unit/directive_block_test.rb

@@ -3,45 +3,53 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/block')
+#require File.join( currentPath, '../../lib/masterview/directives/block')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('block')
 
 class TestBlock < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
+
+  Block = MasterView::Directives::Block  # test subject
+  DirectiveAttrName = Block.attribute_qname
+
+  ELEMENT_TAG = 'div'
 
   def setup
-    @directives = MasterView::DirectiveSet.new
+    create_template_element ELEMENT_TAG
   end
 
-  def test_do
-    @directives.directives = []
+  def test_metadata
+    assert_equal MasterView::ConfigSettings.namespace_prefix, Block.namespace_prefix
+  end
+
+  def test_block_do_end_notation
     attr_value = 'if true do'
-    @directives << Block.new(attr_value)
-    assert_equal "<% #{attr_value} %>", @directives.determine_dcs(:stag).render.join
-    assert_equal "<% end %>", @directives.determine_dcs(:etag).render.join
+    create_directive Block, attr_value
+    assert_equal "<% #{attr_value} -%>", render_element_event(:stag)
+    assert_equal "<% end -%>", render_element_event(:etag)
+
   end
 
-  def test_brack
-    @directives.directives = []
+  def test_block_braces_notation
     attr_value = 'if true {'
-    @directives << Block.new(attr_value)
-    assert_equal "<% #{attr_value} %>", @directives.determine_dcs(:stag).render.join
-    assert_equal "<% } %>", @directives.determine_dcs(:etag).render.join
+    create_directive Block, attr_value
+    assert_equal "<% #{attr_value} -%>", render_element_event(:stag)
+    assert_equal "<% } -%>", render_element_event(:etag)
   end
 
   def test_brack2
-    @directives.directives = []
     attr_value = 'if true { :foo => :bar } {'
-    @directives << Block.new(attr_value)
-    assert_equal "<% #{attr_value} %>", @directives.determine_dcs(:stag).render.join
-    assert_equal "<% } %>", @directives.determine_dcs(:etag).render.join
+    create_directive Block, attr_value
+    assert_equal "<% #{attr_value} -%>", render_element_event(:stag)
+    assert_equal "<% } -%>", render_element_event(:etag)
   end
 
   def test_do2
-    @directives.directives = []
     attr_value = 'if true { :foo => :bar } do'
-    @directives << Block.new(attr_value)
-    assert_equal 1, @directives.directives.size
-    assert_equal "<% #{attr_value} %>", @directives.determine_dcs(:stag).render.join
-    assert_equal "<% end %>", @directives.determine_dcs(:etag).render.join
+    create_directive Block, attr_value
+    assert_equal 1, element_directives.size  #??why are we checking this?? [deb 05-Oct-2006]
+    assert_equal "<% #{attr_value} -%>", render_element_event(:stag)
+    assert_equal "<% end -%>", render_element_event(:etag)
   end
 end

data/test/unit/directive_content_test.rb

@@ -3,24 +3,37 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/content')
+#require File.join( currentPath, '../../lib/masterview/directives/content')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('content')
 
 class TestContent < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
+
+  Content = MasterView::Directives::Content  # test subject
+
+  ELEMENT_TAG = 'div'
+
+  def check_element_rendering(expected)
+
+    erbized_content = "<%= #{expected} %>"
+
+    #??what should we do/check for :stag, :content prcessing points???
+
+    assert_equal '', render_element_event(:etag)
+    assert_equal erbized_content, element_content
+    ###ISSUE: Needs work - this should be verifying that the original tags are preserved
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
-    @tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
   end
 
   def test_hello
-    @directives.directives = []
+
+    create_template_element ELEMENT_TAG
     attr_value = 'hello world'
-    @directives << Content.new(attr_value)
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = @tag.create_context
-    assert_equal '', dcs.render.join
-    assert_equal "<%= #{attr_value} %>", dcs.context[:tag].content
+    create_directive Content, attr_value
+
+    check_element_rendering attr_value
+
   end
 
 end