masterview 0.2.5 → 0.3.0

data/test/unit/directive_omit_tag_test.rb

@@ -3,38 +3,90 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/omit_tag')
+#require File.join( currentPath, '../../lib/masterview/directives/omit_tag')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('omit_tag')
 
 class TestOmit_tag < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
+  OmitTag = MasterView::Directives::OmitTag  # test subject
+
+  ELEMENT_TAG = 'div'
+  ELEMENT_CONTENT = '<p>hello world</p>'
+
+  def test_metadata
+    assert_equal MasterView::ConfigSettings.namespace_prefix, OmitTag.namespace_prefix
+    assert_equal 'omit_tag', OmitTag.attribute_name
   end
 
   def test_omit_tag
-    tag = MasterView::Tag.new(@directives, 'foo', { 'id' => 'foobar', 'style' => 'test'}, :normal, nil)
-    @directives.directives = []
+    create_template_element ELEMENT_TAG,
+                                :attributes => { 'id' => 'foobar', 'style' => 'test'},
+                                :content => ELEMENT_CONTENT
     attr_value = ""
-    @directives << Omit_tag.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 = "hello world"
-    assert_equal nil, dcs.render
+    create_directive OmitTag, attr_value
+    assert_equal '', render_element_event(:stag), 'start tag unconditionally suppressed, not erb checking needed'
+    assert_equal '', render_element_event(:etag), 'start tag unconditionally suppressed, not erb checking needed'
+  end
+
+  def test_omit_tag_true
+    create_template_element ELEMENT_TAG,
+                                :attributes => { 'id' => 'foobar', 'style' => 'test'},
+                                :content => ELEMENT_CONTENT
+    attr_value = "true"
+    create_directive OmitTag, attr_value
+    assert_equal '', render_element_event(:stag), 'start tag unconditionally suppressed, not erb checking needed'
+    assert_equal '', render_element_event(:etag), 'start tag unconditionally suppressed, not erb checking needed'
+  end
+
+  def test_omit_tag_false
+    create_template_element ELEMENT_TAG,
+                                :attributes => { 'id' => 'foobar', 'style' => 'test'},
+                                :content => ELEMENT_CONTENT
+    attr_value = "false"
+    create_directive OmitTag, attr_value
+    assert_equal '', render_element_event(:stag), 'start tag unconditionally generated, not erb checking needed'
+    assert_equal '', render_element_event(:etag), 'start tag unconditionally generated, not erb checking needed'
   end
 
-  def test_omit_tag_eval
-    tag = MasterView::Tag.new(@directives, 'foo', { 'id' => 'foobar', 'style' => 'test'}, :normal, nil)
-    @directives.directives = []
+  def test_omit_tag_conditional
+    create_template_element ELEMENT_TAG,
+                                :attributes => { 'id' => 'foobar', 'style' => 'test'},
+                                :content => ELEMENT_CONTENT
     attr_value = "@test"
-    @directives << Omit_tag.new(attr_value)
-    assert_equal ["<% if @test %>", [], "<% end %>"], @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].content = "hello world"
-    assert_equal ["<% if @test %>", [], "<% end %>"], dcs.render
+    create_directive OmitTag, attr_value
+    expected_content = ["<% if( @test ) -%>", [], "<% end -%>"].join
+    assert_equal expected_content, render_element_event(:stag)
+    expected_content = ["<% if( @test ) -%>", [], "<% end -%>"].join
+    assert_equal expected_content, render_element_event(:etag)
+  end
+
+  def test_complete_rendering_when_tag_omitted
+    create_template_element ELEMENT_TAG, :content => ELEMENT_CONTENT
+    create_directive OmitTag, ''
+    append_default_render_handler
+    assert_equal '', render_element_event(:stag)
+    assert_equal '', render_element_event(:content)
+    assert_equal '', render_element_event(:etag)
+    ###ISSUE: assert_equal ELEMENT_CONTENT, render_element_event(:element) ??why not??
+    assert_equal ELEMENT_CONTENT, element_content
+  end
+
+  #ISSUE: need to debug this test case so it correctly expresses what we're trying to check [DJL 06-Oct-2006]
+  def test_complete_rendering_when_tag_included
+    start_tag = "<#{ELEMENT_TAG}>"
+    end_tag = "</#{ELEMENT_TAG}>"
+    create_template_element ELEMENT_TAG, :content => ELEMENT_CONTENT
+    create_directive OmitTag, 'false'
+    append_default_render_handler
+    assert_equal start_tag, render_element_event(:stag)
+    assert_equal '', render_element_event(:content)
+    assert_equal end_tag, render_element_event(:etag)
+    ###ISSUE: assert_equal ELEMENT_CONTENT, render_element_event(:element) ??why not??
+    #TEMP DISABLE: assert_equal [start_tag, ELEMENT_CONTENT, end_tag].join, element_content
   end
 
+  #TODO: add a test case to verify the complete output element rendering with conditional tag checking
 
 end

data/test/unit/directive_password_field_test.rb

@@ -3,87 +3,93 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/password_field')
+#require File.join( currentPath, '../../lib/masterview/directives/password_field')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('password_field')
 
 class TestPasswordField < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
+  PasswordField = MasterView::Directives::PasswordField  # test subject
+
+  ELEMENT_TAG = 'input'
+
+  def test_metadata
+    assert_equal MasterView::ConfigSettings.namespace_prefix, PasswordField.namespace_prefix
+    assert_equal 'password_field', PasswordField.attribute_name
   end
 
-  def password_field_exec(obj, method, other, options)
+  def create_element_with_password_field_directive(obj, method, other_attr_values, attributes)
+
     attr_value = "#{obj}, #{method}"
-    attr_value << ', ' << other unless other.nil?
-    tag = MasterView::Tag.new(@directives, 'input', options, :normal, nil)
-    @directives.directives = []
-    @directives << Password_field.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 = "hello world"
-    dcs.render
-  end
+    attr_value << ', ' << other_attr_values unless other_attr_values.nil?
+
+    input_tag = create_template_element ELEMENT_TAG,
+                          :attributes => attributes,
+                          :content => 'hello world'
+    create_directive PasswordField, attr_value
+    assert_equal '', render_element_event(:stag)
 
-  def test_normal
-    obj = ':product'
-    method = ':price'
-    ret = password_field_exec(obj, method, nil, { 'type' => 'text', 'value' => 'fake text' } )
-    assert_equal "<%= password_field #{obj}, #{method} %>", ret 
   end
 
-  def test_extra
+  def test_normal
     obj = ':product'
     method = ':price'
-    ret = password_field_exec(obj, method, "'more', 'stuff'", { 'type' => 'text', 'value' => 'fake text' } )
-    assert_equal "<%= password_field #{obj}, #{method} %>", ret 
+    create_element_with_password_field_directive(obj, method, nil, { 'type' => 'text', 'value' => 'fake text' } )
+    expected_content = "<%= password_field( #{obj}, #{method} ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_disabled
     obj = ':product'
     method = ':price'
-    ret = password_field_exec(obj, method, nil, { 'type' => 'text', 'value' => 'fake text', 'disabled' => 'disabled'} )
-    assert_equal "<%= password_field #{obj}, #{method}, :disabled => true %>", ret 
+    create_element_with_password_field_directive(obj, method, nil, { 'type' => 'text', 'value' => 'fake text', 'disabled' => 'disabled'} )
+    expected_content = "<%= password_field( #{obj}, #{method}, :disabled => true ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_size
     obj = ':product'
     method = ':price'
-    ret = password_field_exec(obj, method, nil, { 'type' => 'text', 'value' => 'fake text', 'size' => '10' } )
-    assert_equal "<%= password_field #{obj}, #{method}, :size => 10 %>", ret 
+    create_element_with_password_field_directive(obj, method, nil, { 'type' => 'text', 'value' => 'fake text', 'size' => '10' } )
+    expected_content = "<%= password_field( #{obj}, #{method}, :size => 10 ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_maxlength
     obj = ':product'
     method = ':price'
-    ret = password_field_exec(obj, method, nil, { 'type' => 'text', 'value' => 'fake text', 'maxlength' => '21' } )
-    assert_equal "<%= password_field #{obj}, #{method}, :maxlength => 21 %>", ret 
+    create_element_with_password_field_directive(obj, method, nil, { 'type' => 'text', 'value' => 'fake text', 'maxlength' => '21' } )
+    expected_content = "<%= password_field( #{obj}, #{method}, :maxlength => 21 ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_all
     obj = ':product'
     method = ':price'
-    ret = password_field_exec(obj, method, nil, 
-                          { 
-                            'type' => 'text', 'value' => 'fake text', 'disabled' => 'disabled', 
-                            'size' => '10', 'maxlength' => '21', 
+    create_element_with_password_field_directive(obj, method, nil,
+                          {
+                            'type' => 'text', 'value' => 'fake text', 'disabled' => 'disabled',
+                            'size' => '10', 'maxlength' => '21',
                             'readonly' => 'readonly',  'class' => 'classfoo', 'style' => 'stylebar',
                             'tabindex' => 'tab1', 'accesskey' => 'ak2'
                           } )
-    assert_equal "<%= password_field #{obj}, #{method}, :accesskey => \"ak2\", :class => \"classfoo\", :disabled => true, :maxlength => 21, :readonly => true, :size => 10, :style => \"stylebar\", :tabindex => \"tab1\" %>", ret 
+    expected_content = "<%= password_field( #{obj}, #{method}, :accesskey => \"ak2\", :class => \"classfoo\", :disabled => true, :maxlength => 21, :readonly => true, :size => 10, :style => \"stylebar\", :tabindex => \"tab1\" ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_all_uc
     obj = ':product'
     method = ':price'
-    ret = password_field_exec(obj, method, nil, 
-                          { 
-                            'TYPE' => 'PASSWORD', 'value' => 'fake text', 'DISABLED' => 'DISABLED', 
+    create_element_with_password_field_directive(obj, method, nil,
+                          {
+                            'TYPE' => 'PASSWORD', 'value' => 'fake text', 'DISABLED' => 'DISABLED',
                             'SIZE' => '10', 'MAXLENGTH' => '21',
                             'READONLY' => 'readonly',  'CLASS' => 'classfoo', 'STYLE' => 'stylebar',
                             'TABINDEX' => 'tab1', 'ACCESSKEY' => 'ak2'
                           } )
-    assert_equal "<%= password_field #{obj}, #{method}, :accesskey => \"ak2\", :class => \"classfoo\", :disabled => true, :maxlength => 21, :readonly => true, :size => 10, :style => \"stylebar\", :tabindex => \"tab1\" %>", ret 
+    expected_content = "<%= password_field( #{obj}, #{method}, :accesskey => \"ak2\", :class => \"classfoo\", :disabled => true, :maxlength => 21, :readonly => true, :size => 10, :style => \"stylebar\", :tabindex => \"tab1\" ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
 end

data/test/unit/directive_registry_test.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+currentPath = File.dirname(__FILE__)
+require File.join( currentPath, '../../lib/masterview/directive_metadata' )
+require File.join( currentPath, '../../lib/masterview/directive_registry' )
+
+DEBUG_TRACE = false  #test dev hack
+
+class TestDirectiveRegistry < Test::Unit::TestCase
+
+  # test subject
+  DirectiveRegistry = MasterView::DirectiveRegistry
+
+  def test_current
+
+    assert_not_nil DirectiveRegistry.current
+
+    begin
+      DirectiveRegistry.current.mv_namespace_prefix
+    rescue
+      # this is ordinarily done during masterview initialization
+      DirectiveRegistry.register_default_namespaces( 'mv:', 'mvx:' )
+    end
+
+    assert_not_nil DirectiveRegistry.current.mv_namespace_prefix
+    assert_not_nil DirectiveRegistry.current.mv_extensions_namespace_prefix
+
+    # we maintain separate metadata defaults for mv namespace and extensions
+    assert_not_nil DirectiveRegistry.current.metadata_defaults
+    assert_not_nil DirectiveRegistry.current.metadata_defaults_extensions
+    assert_not_same DirectiveRegistry.current.metadata_defaults, DirectiveRegistry.current.metadata_defaults_extensions
+
+  end
+
+  def test_construction
+   
+    registry = DirectiveRegistry.new
+    #STDOUT.puts "CREATED registry=#{registry}"
+    assert registry.loaded_classes.empty?
+  
+  end
+
+end

data/test/unit/directive_replace_test.rb

@@ -3,25 +3,41 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/replace')
+#require File.join( currentPath, '../../lib/masterview/directives/replace')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('replace')
 
 class TestReplace < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
+
+  Replace = MasterView::Directives::Replace  # test subject
+
+  ELEMENT_TAG = 'h1'
+  TEMPLATE_ELEMENT_ATTRIBUTES = { 'id' => 'foobar', 'style' => 'test'}
+
+  def check_element_rendering(expected_content)
+
+    erbized_content = "<%= #{expected_content} %>"
+    assert_equal '', render_element_event(:stag)
+    #??what to do/check at :content processing point?
+    assert_equal erbized_content, render_element_event(:etag)
+ 
+    ###ISSUE: Needs work (?) - this should be verifying that the original tags are dropped
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
   end
 
   def test_replace
-    tag = MasterView::Tag.new(@directives, 'foo', { 'id' => 'foobar', 'style' => 'test'}, :normal, nil)
-    @directives.directives = []
+
+    # ensure we have some sample content that's getting replaced
+    test_element = create_template_element ELEMENT_TAG, 
+                      :attribute => TEMPLATE_ELEMENT_ATTRIBUTES,
+                      :content => "product name goes here"
+
     attr_value = "h @product[name]"
-    @directives << Replace.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 = "hello world"
-    assert_equal "<%= h @product[name] %>", dcs.render
+    create_directive Replace, attr_value
+
+    check_element_rendering attr_value
+
   end
 
 end

data/test/unit/directive_stylesheet_link_test.rb

@@ -3,61 +3,68 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/stylesheet_link' )
+#require File.join( currentPath, '../../lib/masterview/directives/stylesheet_link' )
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('stylesheet_link')
 
 class StylesheetLinkTest < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
+  StylesheetLink = MasterView::Directives::StylesheetLink  # test subject
+
+  ELEMENT_TAG = 'link'
+
+  def test_metadata
+    assert_equal MasterView::ConfigSettings.namespace_prefix, StylesheetLink.namespace_prefix
+    assert_equal 'stylesheet_link', StylesheetLink.attribute_name
   end
 
   def test_default
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
-    attr_value = "hello world"
-    @directives << Stylesheet_link.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    assert_equal "<%= stylesheet_link_tag 'hello world' %>", dcs.render
+    create_template_element ELEMENT_TAG
+    attr_value = "styles.css"
+    create_directive StylesheetLink, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= stylesheet_link_tag( '#{attr_value}' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_empty_infer_path
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
+    link_tag = create_template_element ELEMENT_TAG,
+                      :attributes => { 'src' => '../../public/stylesheets/foo.css' }
     attr_value = ""
-    @directives << Stylesheet_link.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].attributes['src'] = '../../public/stylesheets/foo.css'
-    assert_equal "<%= stylesheet_link_tag 'foo.css' %>", dcs.render
+    create_directive StylesheetLink, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= stylesheet_link_tag( 'foo.css' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_empty_infer_path_sub
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
+    link_tag = create_template_element ELEMENT_TAG,
+                      :attributes => { 'src' => '../../public/stylesheets/bar/foo.css' }
     attr_value = ""
-    @directives << Stylesheet_link.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].attributes['src'] = '../../public/stylesheets/bar/foo.css'
-    assert_equal "<%= stylesheet_link_tag 'bar/foo.css' %>", dcs.render
+    create_directive StylesheetLink, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= stylesheet_link_tag( 'bar/foo.css' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_empty_use_src
-    tag = MasterView::Tag.new(@directives, 'foo', {}, :normal, nil)
-    @directives.directives = []
+    link_tag = create_template_element ELEMENT_TAG,
+                      :attributes => { 'src' => '/mystylesheets/foo.css' }
     attr_value = ""
-    @directives << Stylesheet_link.new(attr_value)
-    assert_equal nil, @directives.determine_dcs(:stag).render
-    dcs = @directives.determine_dcs(:etag)
-    dcs.context = tag.create_context
-    dcs.context[:tag].attributes['src'] = '/mystylesheets/foo.css'
-    assert_equal "<%= stylesheet_link_tag '/mystylesheets/foo.css' %>", dcs.render
+    create_directive StylesheetLink, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= stylesheet_link_tag( '/mystylesheets/foo.css' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
+  def test_multiple
+    link_tag = create_template_element ELEMENT_TAG
+    attr_value = "hello/world, foo/bar, baz"
+    create_directive StylesheetLink, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= stylesheet_link_tag( 'hello/world', 'foo/bar', 'baz' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
+  end
 
 end

data/test/unit/directive_submit_test.rb

@@ -3,52 +3,51 @@
 require 'test/unit'
 currentPath = File.dirname(__FILE__)
 require File.join( currentPath, '../../lib/masterview' )
-require File.join( currentPath, '../../lib/masterview/directives/submit')
+#require File.join( currentPath, '../../lib/masterview/directives/submit')
+require File.join( currentPath, '../directive_test_helper' )
+DirectiveTestHelpers.load_masterview_directive('submit')
 
 class TestSubmitTag < Test::Unit::TestCase
-  include MasterView::Directives
+  include DirectiveTestHelpers
 
-  def setup
-    @directives = MasterView::DirectiveSet.new
-  end
+  Submit = MasterView::Directives::Submit  # test subject
+
+  ELEMENT_TAG = 'input'
 
   def test_submit
     submit_text = 'foobar'
-    tag = MasterView::Tag.new(@directives, 'input', { 'type' => 'submit', 'value' => submit_text }, :normal, nil)
-    @directives.directives = []
+    create_template_element ELEMENT_TAG,
+                      :attributes => { 'type' => 'submit', 'value' => submit_text },
+                      :content => 'hello world'
     attr_value = "baz"
-    @directives << Submit.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 = "hello world"
-    assert_equal "<%= submit_tag '#{submit_text}' %>", dcs.render
+    create_directive Submit, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= submit_tag( '#{submit_text}' ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_submit_with_hash
     submit_text = 'foobar'
-    tag = MasterView::Tag.new(@directives, 'input', { 'type' => 'submit', 'value' => submit_text }, :normal, nil)
-    @directives.directives = []
-    attr_value = "{:foo => 'bar' }"
-    @directives << Submit.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 = "hello world"
-    assert_equal "<%= submit_tag '#{submit_text}', #{attr_value} %>", dcs.render
+    create_template_element ELEMENT_TAG,
+                      :attributes => { 'type' => 'submit', 'value' => submit_text },
+                      :content => 'hello world'
+    attr_value = "{:foo => 'bar'}"
+    create_directive Submit, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= submit_tag( '#{submit_text}', #{attr_value} ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
   def test_submit_with_hash_no_brack
     submit_text = 'foobar'
-    tag = MasterView::Tag.new(@directives, 'input', { 'type' => 'submit', 'value' => submit_text }, :normal, nil)
-    @directives.directives = []
+    create_template_element ELEMENT_TAG,
+                      :attributes => { 'type' => 'submit', 'value' => submit_text },
+                      :content => 'hello world'
     attr_value = ":foo => 'bar'"
-    @directives << Submit.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 = "hello world"
-    assert_equal "<%= submit_tag '#{submit_text}', #{attr_value} %>", dcs.render
+    create_directive Submit, attr_value
+    assert_equal '', render_element_event(:stag)
+    expected_content = "<%= submit_tag( '#{submit_text}', #{attr_value} ) %>"
+    assert_equal expected_content, render_element_event(:etag)
   end
 
 end