trace-util-adv 0.2.4 → 0.3.0

data/test/appenders/include.rb

@@ -0,0 +1,4 @@
+require "trace-util-adv"
+Require.base_path = File.dirname(__FILE__)
+Require.folder "../samples"
+require "test/unit"

data/test/appenders/test_appender_templates.rb

@@ -0,0 +1,57 @@
+require "include"
+
+
+class TestAppenderTemplates < Test::Unit::TestCase
+
+  def setup
+    # Trace filters
+    im_filter_1 = {:i_method_filter => "a,b"}
+    xym_class_1 = {:xy_class_filter => "C,D"}
+    @filters = [im_filter_1, xym_class_1]
+
+    @app_filter_1 = {:x_class_filter => "Dryml"}
+    @app_filter_2 = {:i_class_filter => "Template"}
+
+    @xml_tracer = {:type => :xml, :to_file => 'log_files/xml/traced.xml'}.template
+    
+    puts "xmltracer: #{@xml_tracer.inspect}"
+    
+    # @html_tracer = {:type => :html, :default_path => 'log_files/html/'}.template
+    # @log_tracer = {:type => :log}.template
+    # @stream_tracer = {:type => :stream}.template
+  end  
+  
+
+  def test_appender_register_tracer
+    # Trace configuration    
+    
+    appender_1 = {:template => @xml_tracer}.appender
+    assert_equal Tracing::XmlAppender, appender_1.class, "Should create instance of XmlAppender"
+
+    # appender_2 = {:template => @html_tracer}.appender
+    # assert_equal Tracing::HtmlAppender, appender_2.class, "Should create instance of HtmlAppender"
+    # 
+    # appender_3 = {:template => @log_tracer}.appender
+    # assert_equal Tracing::HtmlAppender, appender_3.class, "Should create instance of LogAppender"
+    # 
+    # appender_4 = {:template => @stream_tracer}.appender
+    # assert_equal Tracing::StreamAppender, appender_4.class, "Should create instance of StreamAppender"
+  end
+
+
+  def test_appender_register_tracer_and_filters
+    # Trace configuration
+    # appender_1 = {:template => @xml_tracer, :filters => @app_filter_1}.appender
+    # assert_equal Tracing::XmlAppender, appender_1.class, "Should create instance of XmlAppender"
+
+    # appender_2 = {:template => @html_tracer, :filters => @app_filter_1}.appender
+    # assert_equal Tracing::HtmlAppender, appender_2.class, "Should create instance of HtmlAppender"
+    # 
+    # appender_3 = {:template => @log_tracer, :filters => @app_filter_1}.appender
+    # assert_equal Tracing::HtmlAppender, appender_3.class, "Should create instance of LogAppender"
+    # 
+    # appender_4 = {:template => @stream_tracer, :filters => @app_filter_1}.appender
+    # assert_equal Tracing::StreamAppender, appender_4.class, "Should create instance of Streamppender"
+  end
+
+end

data/test/appenders/test_create_appender.rb

@@ -1,33 +1,32 @@
-require 'extensions/core_extensions'
-require "test/unit"
+require "include"
 
 
 class TestAppenderTracers < Test::Unit::TestCase
 
   def test_exec_xml_tracer
-    xml_tracer = {:type => :xml, :to_file => 'log_files/xml/traced.xml'}.tracer
-    assert_equal Tracing::XmlAppender, xml_tracer.class, "Should create instance of XmlTracer"
+    xml_tracer = {:type => :xml, :to_file => 'log_files/xml/traced.xml'}.appender
+    assert_equal Tracing::XmlAppender, xml_tracer.class, "Should create instance of XmlAppender"
     
     xml_tracer.trace('hello world')    
   end
 
   def test_exec_html_tracer
-    html_tracer = {:type => :html, :default_path => 'log_files/html'}.tracer
-    assert_equal Tracing::HtmlAppender, html_tracer.class, "Should create instance of HtmlTracer"
+    html_tracer = {:type => :html, :default_path => 'log_files/html'}.appender
+    assert_equal Tracing::HtmlAppender, html_tracer.class, "Should create instance of HtmlAppender"
      
     html_tracer.trace('hello world')
   end
 
   def test_exec_log_tracer
-    log_tracer = {:type => :log, :default_path => 'log_files'}.tracer
-    assert_equal Tracing::LoggerAppender, log_tracer.class, "Should create instance of LogTracer"
+    log_tracer = {:type => :log, :default_path => 'log_files'}.appender
+    assert_equal Tracing::LoggerAppender, log_tracer.class, "Should create instance of LogAppender"
     
     log_tracer.trace('hello world')
   end
 
   def test_exec_log_tracer
-    appender = {:type => :stream, :stream => :STDOUT}.tracer
-    assert_equal Tracing::StreamAppender, log_tracer.class, "Should create instance of StreamTracer"
+    appender = {:type => :stream, :stream => :STDOUT}.appender
+    assert_equal Tracing::StreamAppender, log_tracer.class, "Should create instance of StreamAppender"
     
     stream_tracer.trace('hello world')
   end

data/test/extensions/include.rb

@@ -0,0 +1,4 @@
+require "trace-util-adv"
+Require.base_path = File.dirname(__FILE__)
+Require.folder "../samples"
+require "test/unit"

data/test/extensions/test_filters_creation.rb

@@ -1,36 +1,12 @@
-require 'extensions/core_extensions'
-require 'filters/base_filters'
-require 'rules/hash_rule_extensions'
-require "test/unit"
-
+require "include"
 
 class TestFiltersCreation < Test::Unit::TestCase
 
   def test_try_create_method_include_filter
     hash = {:i_method_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    expected = {:method_filter => {:include => "a,b"}}
-    puts filter_hash.inspect
-    assert_equal expected, filter_hash, "Should create method include filter"
+    imethod_filter = hash.create_filter
+    expected = Tracing::MethodFilter
+    assert_equal expected, imethod_filter.class, "Should create method include filter"
   end
 
-  def test_filters_creation
-    # config = {:filters => []}
-    # result = config.filters
-    # assert_equal result.blank?, true, "Should result in empty filters list"    
-
-    im_filter = {:i_method_filter => "a,b"}
-    config = {:filters => im_filter}
-    
-    res = im_filter.filters
-    puts "res: #{res.inspect}"
-    
-    result = config.filters
-    puts "result: #{result.inspect}"
-    # assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
-  
-    # puts "rules: #{result.rules.inspect}"
-    # expected = {:method_filter => {:include => "a, b"} }
-    # assert_equal expected, result.rules, "Should result in method rules"    
-  end
 end

data/test/extensions/test_hash_extensions.rb

@@ -1,8 +1,4 @@
-require 'extensions/core_extensions'
-require 'filters/base_filters'
-require 'rules/hash_rule_extensions'
-require "test/unit"
-
+require "include"
 
 class TestHashExtensions < Test::Unit::TestCase
 
@@ -20,39 +16,39 @@ class TestHashExtensions < Test::Unit::TestCase
     result = mapper.map(:w)
     assert_equal result, 3, ":w Should result in default 3"
   end
-
+  
   def test_method_full_name
     my_instance_variables = {:template_path => 'taglibs/rapid_core.dryml'}    
-    context_hash = {:class_name => "Alpha::Beta::Gamma", :method_name => "meth_a", :vars => [my_instance_variables], :args => {:a => 7} }
-    context.set_context context_hash
+    context = {:class_name => "Alpha::Beta::Gamma", :method_name => "meth_a", :vars => [my_instance_variables], :args => {:a => 7} }.context
+    puts context
     result = context.full_method_name
     assert_equal result, 'Alpha::Beta::Gamma.meth_a', "Should result in 'Alpha::Beta::Gamma.meth_a'"
   end
-
+  
   def test_rules_allow_action_include
     rule = {:include => ['a']}
     result = rule.rules_allow_action('a')
     assert_equal result, :include, "Should include a"
   end
-
+  
   def test_rules_allow_action_yield
     rule = {:include => ['a']}
     result = rule.rules_allow_action('b')
     assert_equal result, :yield, "Should yield a"
   end
-
+  
   def test_rules_allow_action_exclude
     rule = {:exclude => ['a']}
     result = rule.rules_allow_action('a')
     assert_equal result, :exclude, "Should exclude a"
   end
-
+  
   def test_rules_allow_action_exclude_and_yield
     rule = {:exclude_and_yield => ['a']}
     result = rule.rules_allow_action('a')
     assert_equal result, :exclude_and_yield, "Should exclude_an_yield a"
   end
-
+  
   # TODO
   # rule_allow_action(name) NEEDS MAJOR CLEANUP AND REFACTOR!!!
   def test_rules_allow_action_include_and_yield
@@ -60,80 +56,80 @@ class TestHashExtensions < Test::Unit::TestCase
     result = rule.rules_allow_action('a')
     assert_equal result, :include_and_yield, "Should include_an_yield a"
   end
-
+  
   def test_rule_list
     rules = ['a']
     result = rules.rule_list
     assert_equal result, rules, "Should not change rule"
-
+  
     rules = ['a', 'b']
     result = rules.rule_list
     assert_equal result, rules, "Should not change rules"
-
+  
     rules = "a b"
     result = rules.rule_list
     assert_equal result, ['a', 'b'], "Should split rules"
   end
-
+  
   # return a symbol, either - :include, :exclude or :yield (let next filter decide)
   def test_rule_allow_action
     rule = {:include => ['a']}
     result = rule.rule_allow_action('a')
     assert_equal result, :include, "Should :include"
-
+  
     rule = {:exclude => ['a']}
     result = rule.rule_allow_action('a')
     assert_equal result, :exclude, "Should :exclude"
-
+  
     rule = {:include_and_yield => ['a']}
     result = rule.rule_allow_action('a')
     assert_equal result, :include_and_yield, "Should :include_and_yield"
-
+  
     rule = {:exclude_and_yield => ['a']}
     result = rule.rule_allow_action('a')
     assert_equal result, :exclude_and_yield, "Should :exclude_and_yield"
-
+  
     rule = {:yield => ['a']}
     result = rule.rule_allow_action('a')
     assert_equal result, :yield, "Should :yield"
-
+  
     rule = {:include => ['a']}
     result = rule.rule_allow_action('a')
     assert_equal result, :include, "Should :include"
-
+  
     rule = {:include => ['b'], :exclude => "a"}
     result = rule.rule_allow_action('a')
     assert_equal result, :exclude, "Should :exclude"
-
+  
     rule = {:include => ['a'], :exclude => "a"}
     result = rule.rule_allow_action('a')
     assert_equal result, :include, "Should :include"
-
+  
   end
-
-  def test_tracer
-    rule = {:tracer => :html}
-    result = rule.tracer
-    assert_equal result.class, Tracing::OutputTemplate::HtmlTrace, "Should result in HtmlTrace"    
-
-    rule = {:tracer => :xml}
-    result = rule.tracer
-    assert_equal result.class, Tracing::OutputTemplate::XmlTrace, "Should result in XmlTrace"    
-
-    rule = {:tracer => :string}
-    result = rule.tracer
-    assert_equal result.class, Tracing::OutputTemplate::StringTrace, "Should result in StringTrace"    
+  
+  def test_create_template
+    rule = {:template => :html}
+    result = rule.template
+    assert_equal result.class, Tracing::HtmlTemplate, "Should result in HtmlTrace"    
+  
+    rule = {:template => :xml}
+    result = rule.template
+    assert_equal result.class, Tracing::XmlTemplate, "Should result in XmlTrace"    
+  
+    rule = {:template => :string}
+    result = rule.template
+    assert_equal result.class, Tracing::StringTemplate, "Should result in StringTrace"    
   end
   
   def test_appenders
     config = {:appenders => []}
     result = config.appenders
     assert_equal result.blank?, true, "Should result in empty appender list"    
-
+  
     config = {:appenders => :html}
     result = config.appenders
     assert_equal result.class, Tracing::HtmlAppender, "Should result in empty appender list"    
-
+  
     config = {:appenders => [:xml, :html]}
     result = config.appenders
     assert_equal Tracing::XmlAppender, result[0].class, "Should result in xml appender"        
@@ -144,15 +140,15 @@ class TestHashExtensions < Test::Unit::TestCase
     config = {:action_handlers => []}
     result = config.action_handlers
     assert_equal result.blank?, true, "Should result in empty action_handler list"    
-
+  
     config = {:action_handlers => {:appenders => :html}}
     result = config.action_handlers
     assert_equal Tracing::HtmlAppender, result.appenders[0].class, "Should result in action handler with HtmlAppender registered"    
-
+  
     config = {:action_handlers => {:filters => {:i_method_filter => "a,b"}}}
     result = config.action_handlers
     assert_equal Tracing::MethodFilter, result.filters[0].class, "Should result in action handler with MethodFilter registered"    
-
+  
     ah1 = {:filters => {:i_method_filter => "a,b"}, :appenders => :html}
     ah2 = {:filters => {:x_method_filter => "c,d"}, :appenders => :xml}
     
@@ -165,6 +161,7 @@ class TestHashExtensions < Test::Unit::TestCase
   def test_create_filter
     config = {:i_method_filter => "a,b"}
     result = config.create_filter
+    puts result.inspect
     assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
 
     config = {:filters => {:i_method_filter => "a,b"}}
@@ -177,13 +174,13 @@ class TestHashExtensions < Test::Unit::TestCase
     result = config.create_filter_hash
     exp_result = {:method_filter => { :include => "a,b" } }
     assert_equal exp_result, result, "Should result in :method_filter hash with :include name rules"    
-
+  
     config = {:xy_class_filter => "a,b"}
     result = config.create_filter_hash
     exp_result = {:class_filter => { :exclude_and_yield => "a,b" } }
     assert_equal exp_result, result, "Should result in :class_filter hash with :exclude_and_yield name rules"    
   end
-
+  
   def test_try_create_filter_hash
     config = {:i_method_filter => "a,b"}
     result = config.create_filter_hash
@@ -195,13 +192,13 @@ class TestHashExtensions < Test::Unit::TestCase
     config = {:filters => []}
     result = config.filters
     assert_equal result.blank?, true, "Should result in empty filters list"    
-
+  
     config = {:filters => {:i_method_filter => "a,b"}}
     result = config.filters
     assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
     
     puts result.rules.inspect
-    expected = {:method_filter => {:include => "a, b"} }
+    expected = {:include => "a,b"}
     assert_equal expected, result.rules, "Should result in method rules"    
   end
     

data/test/extensions/test_hash_filter_extensions.rb

@@ -1,5 +1,4 @@
-require 'extensions/core_extensions'
-require "test/unit"
+require "include"
 
 
 class TestHashFilterFilter < Test::Unit::TestCase
@@ -13,53 +12,71 @@ class TestHashFilterFilter < Test::Unit::TestCase
             
   def test_try_create_method_include_filter
     hash = {:i_method_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:method_filter => {:include => "a,b"}}, "Should create method include filter"
+    mfilter = hash.create_filter
+    expected = Tracing::MethodFilter
+    assert_equal expected, mfilter.class, "Should create method include filter"
+    exp = {:include => "a,b"}
+    assert_equal exp, mfilter.rules, "Expected include rules"
   end
   
   def test_try_create_method_exclude_filter
     hash = {:x_method_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:method_filter => {:exclude => "a,b"}}, "Should create method exclude filter"
+    mfilter = hash.create_filter
+    expected = Tracing::MethodFilter
+    assert_equal expected, mfilter.class, "Should create method exclude filter"
+    exp = {:exclude =>"a,b"}
+    assert_equal exp, mfilter.rules, "Expected exclude rules"
   end
-
+  
   def test_try_create_method_include_and_yield_filter
     hash = {:iy_method_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:method_filter => {:include_and_yield => "a,b"}}, "Should create method include_an_yield filter"
+    mfilter = hash.create_filter
+    expected = Tracing::MethodFilter
+    assert_equal expected, mfilter.class, "Should create method include filter"
+    exp = {:include_and_yield => "a,b"}
+    assert_equal exp, mfilter.rules, "Expected include and yield rules"
   end
-
+  
   def test_create_method_exclude_and_yield_filter
     hash = {:xy_method_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:method_filter => {:exclude_and_yield => "a,b"}}, "Should create method exclude_and_yield filter"
+    mfilter = hash.create_filter
+    expected = Tracing::MethodFilter
+    puts "FILTER: #{mfilter.inspect}"        
+    assert_equal expected, mfilter.class, "Should create method exclude filter"
+    exp = {:exclude_and_yield => "a,b"}
+    assert_equal exp, mfilter.rules, "Expected exclude and yield rules"
   end
-
+  
   def test_try_create_class_exclude_and_yield_filter
     hash = {:xy_class_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:class_filter => {:exclude_and_yield => "a,b"}}, "Should create class exclude_and_yield filter"
+    mfilter = hash.create_filter
+    expected = Tracing::ClassFilter
+    assert_equal expected, mfilter.class, "Should create class exclude filter"
+    exp = {:exclude_and_yield => "a,b"}
+    puts mfilter.inspect
+    assert_equal exp, mfilter.rules, "Expected exclude and yield rules"
   end
-
+  
   def test_try_create_module_exclude_and_yield_filter
     hash = {:xy_module_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:module_filter => {:exclude_and_yield => "a,b"}}, "Should create module exclude_and_yield filter"
+    mfilter = hash.create_filter
+    expected = Tracing::ModuleFilter
+    assert_equal expected, mfilter.class, "Should create module exclude filter"
+    exp = {:exclude_and_yield => "a,b"}
+    puts mfilter.inspect
+    assert_equal exp, mfilter.rules, "Expected exclude and yield rules"
   end
-
+  
   def test_try_create_vars_exclude_and_yield_filter
     hash = {:xy_vars_filter => 'a,b'}
-    filter_hash = hash.create_filter
-    # puts filter_hash.inspect
-    assert_equal filter_hash, {:vars_filter => {:exclude_and_yield => "a,b"}}, "Should create vars exclude_and_yield filter"
+    mfilter = hash.create_filter
+    expected = Tracing::InstanceVarFilter
+    assert_equal expected, mfilter.class, "Should create vars exclude filter"
+    exp = {:exclude_and_yield => "a,b"}
+    puts mfilter.inspect
+    assert_equal exp, mfilter.rules, "Expected exclude and yield rules"
   end
-
+  
   
 end