trace-util-adv 0.2.3 → 0.2.4

data/test/extensions/test_hash_extensions.rb

@@ -0,0 +1,208 @@
+require 'extensions/core_extensions'
+require 'filters/base_filters'
+require 'rules/hash_rule_extensions'
+require "test/unit"
+
+
+class TestHashExtensions < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+    ## Nothing really
+  end
+
+  def test_map
+    mapper = {:x => 1, :y => 2, :default => 3}
+    result = mapper.map(:x)
+    assert_equal result, 1, ":x Should result in 1"
+    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
+    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
+    rule = {:include_and_yield => ['a']}
+    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"    
+  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"        
+    assert_equal Tracing::HtmlAppender, result[1].class, "Should also result in html appender"    
+  end
+  
+  def test_action_handlers
+    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}
+    
+    config = {:action_handlers => [ah1, ah2]}
+    result = config.action_handlers
+    assert_equal Tracing::MethodFilter, result[0].filters[0].class, "Should result in action handler with MethodFilter registered"    
+    assert_equal Tracing::MethodFilter, result[1].filters[0].class, "Should result in action handler with MethodFilter registered"    
+  end
+  
+  def test_create_filter
+    config = {:i_method_filter => "a,b"}
+    result = config.create_filter
+    assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
+
+    config = {:filters => {:i_method_filter => "a,b"}}
+    result = config.create_filter
+    assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
+  end
+
+  def test_create_filter_hash
+    config = {:i_method_filter => "a,b"}
+    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
+    exp_result = {:method_filter => { :include => "a,b" } }
+    assert_equal exp_result, result, "Should result in :method_filter hash with :include name rules"    
+  end
+  
+  def test_filters
+    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"} }
+    assert_equal expected, result.rules, "Should result in method rules"    
+  end
+    
+end

data/test/extensions/test_hash_filter_extensions.rb

@@ -0,0 +1,65 @@
+require 'extensions/core_extensions'
+require "test/unit"
+
+
+class TestHashFilterFilter < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+    ## Nothing really
+  end
+            
+  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"
+  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"
+  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"
+  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"
+  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"
+  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"
+  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"
+  end
+
+  
+end
+

data/test/extensions/test_set_context.rb

@@ -0,0 +1,94 @@
+require 'extensions/core_extensions'
+require 'filters/base_filters'
+require 'rules/hash_rule_extensions'
+require "test/unit"
+
+class Person
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+end
+
+
+class TestHashExtensions < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+    ## Nothing really
+  end
+
+  def test_set_context
+    context = {:class_name => "Hobo::Dryml", :method_name => "build_a"}.context
+    expected = {
+      :class_name       =>"Dryml", 
+      :method_name      =>"build_a", 
+      :modules          =>["Hobo"], 
+      :full_class_name  =>"Hobo::Dryml",
+      :full_modules_name=>"Hobo",
+      :full_method_name =>"Hobo::Dryml.build_a"      
+    }
+
+    assert_equal expected, context, "resulting @context not as expected"    
+  end
+
+  def test_set_context_modules
+    context = {:modules => ["Hobo"], :class_name => "Dryml", :method_name => "build_a"}.context
+    puts "context set:" + context.inspect
+    expected = {
+      :method_name      =>"build_a",
+      :class_name       => "Dryml",
+      :modules          =>["Hobo"], 
+      :full_class_name  =>"Hobo::Dryml",
+      :full_modules_name=>"Hobo",
+      :full_method_name =>"Hobo::Dryml.build_a"       
+    }
+
+    assert_equal expected, context, "resulting @context not as expected"    
+  end
+
+  def test_set_context_instance_vars
+    context = {:vars => [{:a => 12, :b => "B"}]}.context
+    puts "context set:" + context.inspect
+    expected = {
+      :vars => [{:a => 12, :b => "B"}]              
+    }
+
+    assert_equal expected, context, "resulting @context not as expected"    
+  end
+
+  def test_set_context_args
+    context = {:args => [{:a => 12, :b => "B"}]}.context
+    puts "context set:" + context.inspect
+    expected = {
+      :args => [{:a => 12, :b => "B"}]              
+    }
+
+    assert_equal expected, context, "resulting @context not as expected"    
+  end
+
+  def test_set_context_block
+    context = {:block => true}.context
+    puts "context set:" + context.inspect
+    expected = {
+      :block => true              
+    }
+
+    assert_equal expected, context, "resulting @context not as expected"    
+  end
+
+  def test_set_context_self
+    obj = Person.new "Kristian"
+    context = {:block => true, :self => obj}.context
+    puts "context set:" + context.inspect
+    expected = {
+      :self => obj              
+    }
+
+    assert_equal expected, context, "resulting @context not as expected"    
+    assert_equal "Kristian", context[:self].name, "Kristian expected as person name"    
+  end
+end

data/test/extensions/test_string_extensions.rb

@@ -0,0 +1,55 @@
+require 'extensions/core_extensions'
+require "test/unit"
+
+
+class TestFilter < Test::Unit::TestCase
+            
+  def test_split_names
+    names = nil
+    result = names.split_names
+    expected = ["alpha", "beta"]
+    assert_equal nil, result, "No names should result in nil"
+
+    names = "alpha, beta"
+    result = names.split_names
+    expected = ["alpha", "beta"]
+    assert_equal expected, result, "Should be split into list of names"
+
+    names = "alpha   beta"
+    result = names.split_names
+    expected = ["alpha", "beta"]
+    assert_equal expected, result, "Should be split into list of names"
+
+    names = "alpha  ,   beta"
+    result = names.split_names
+    expected = ["alpha", "beta"]
+    assert_equal expected, result, "Should be split into list of names"
+  end
+  
+  def test_modules
+    name = "Alpha::Beta::Gamma"
+    result = name.modules
+    expected = ["Alpha","Beta"]
+    assert_equal expected, result, "Should be split into list of module names"    
+  end
+
+  def test_class_name
+    name = "Alpha::Beta"    
+    result = name.class_name
+    expected = "Beta"
+    assert_equal expected, result, "Should be last part of module name"
+  end
+  
+  def test_in_module?(module_name)
+    name = "Alpha::Beta"    
+    result = name.in_module?("Alpha")
+    expected = true
+    assert_equal expected, result, "Should be in module"
+
+    result = name.in_module?("Gamma")
+    expected = true
+    assert_equal expected, result, "Should NOT be in module"
+  end  
+  
+end
+

data/test/extensions/test_symbol_extensions.rb

@@ -0,0 +1,35 @@
+require 'extensions/core_extensions'
+require "test/unit"
+
+
+class TestSymbolExtensions < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+    ## Nothing really
+  end
+            
+  def test_prefix
+    prefixed_symbol = :test.prefix(:xy)    
+    assert_equal prefixed_symbol, :xy_test, "Should result in :xy_test"
+  end
+  
+  def test_trace_class
+    result = :xml.trace_class
+    assert_equal result, Tracing::OutputTemplate::XmlTrace, ":xml Should result in XmlTrace"            
+  end
+  
+  def appender_class
+    result = :xml.trace_class
+    assert_equal result, Tracing::XmlAppender, ":xml Should result in XmlTrace"            
+  end
+  
+  def test_rule
+    result = :i.rule
+    assert_equal result, :include, ":i Should result in :include"
+  end
+
+  
+end

data/test/{test_filters_chain.rb → filters/chain/test_filters_chain.rb}

@@ -70,9 +70,10 @@ class TestFilter < Test::Unit::TestCase
     names_A = %w{blip blop}
     names_B = "blip blop"
     names_C = "blip, blop"
-
     bfil = {:xmethod_filter => names_B}
 
+    my_method_filter = {:xmethod_filter => "method_a, method b"}
+
     # method_filter_A = Tracing::Filter.create_filter({:imethod_filter =>  names_A})        
     method_filter_B = Tracing::Filter.create_filter(bfil)        
     # method_filter_C = Tracing::Filter.create_filter({:imethod_filter =>  names_C})        

data/test/filters/composite/test_composite_class_filter.rb

@@ -0,0 +1,78 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+Class_composite_filter_A = {
+  # id of composite rule set  
+  :name => 'Template stuff',
+  :default => :exclude,
+  :classes => [{
+    :names => [/Dryml/],
+    :method_rules => {
+      :include => [/build.*/, 'exec'],
+      :exclude => ['add'],
+      :default => :exclude
+    }
+  }]
+}
+
+class TestCompositeFilter < Test::Unit::TestCase
+
+  def test_composite_class_filter_hash_to_class
+    composite_filter = Class_composite_filter_A
+    result = composite_filter.filter_class
+    assert_equal Tracing::CompositeClassFilter, result, "Should result in composite class filter"    
+  end
+
+  def test_composite_class_filter_hash_to_class
+    composite_filter = Class_composite_filter_A
+    result = composite_filter.create_filter
+    assert_equal Tracing::CompositeClassFilter, result.class, "Should result in composite class filter"    
+  end
+  
+  
+  def test_composite_class_filter_from_hash
+    composite_filter = Class_composite_filter_A
+    config = {:filters => composite_filter}    
+    result = config.filters
+    assert_equal Tracing::CompositeClassFilter, result.class, "Should result in method filter"    
+  end
+
+  # see allow_action in CompositeClassFilter, refactor :yield, :include .. as return values!?
+  def test_composite_class_filter__class_and_method_match
+    composite_filter = Class_composite_filter_A
+  
+    context = {}
+    context.set_context :class_name => "Hobo::Dryml", :method_name => "build_a"
+  
+    options = {:filters => composite_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal true, result, "Filter should allow passage"    
+  end
+
+  def test_composite_class_filter__class_not_match
+    composite_filter = Class_composite_filter_A
+  
+    context = {}    
+    context.set_context :class_name => 'Blip::Blap'
+    
+    options = {:filters => composite_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal false, result, "Filter should NOT allow passage"    
+  end
+
+  def test_composite_class_filter__method_excluded
+    composite_filter = Class_composite_filter_A
+  
+    context = {}    
+    context.set_context :class_name => "Hobo::Dryml", :method_name => "add_it"
+    
+    options = {:filters => composite_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal false, result, "Filter should NOT allow passage"    
+  end
+              
+end

data/test/filters/composite/test_composite_module_filter.rb

@@ -0,0 +1,82 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+Module_composite_filter_A = {
+  # id of composite rule set    
+  :name => 'dryml_filter',
+  :modules => [{
+    :names => ['Hobo::Dryml', /Dryml/],
+    :class_rules => {
+      :include => [/Template.*/, 'DRYMLBuilder'],
+      :exclude => ['Taglib'],
+      :default => :include
+    },
+    :method_rules => {
+      :include => [/blip.*/, 'blap'],
+      :exclude => ['add_it'],
+      :default => :include
+    }
+  }]
+}
+
+
+class TestCompositeModuleFilter < Test::Unit::TestCase
+
+  def test_composite_module_filter_hash_to_module
+    composite_filter = Module_composite_filter_A
+    result = composite_filter.filter_module
+    assert_equal Tracing::CompositeModuleFilter, result, "Should result in composite module filter"    
+  end
+
+  def test_composite_module_filter_hash_to_module
+    composite_filter = Module_composite_filter_A
+    result = composite_filter.create_filter
+    assert_equal Tracing::CompositeModuleFilter, result.class, "Should result in composite module filter"    
+  end
+
+  def test_composite_module_filter_from_hash
+    composite_filter = Module_composite_filter_A
+    config = {:filters => composite_filter}    
+    result = config.filters
+    assert_equal Tracing::CompositeModuleFilter, result.class, "Should result in composite module filter"    
+  end
+
+  # see allow_action in CompositeModuleFilter, refactor :yield, :include .. as return values!?
+  def test_composite_module_filter__module_and_method_match
+    composite_filter = Module_composite_filter_A
+  
+    context = {}
+    context.set_context :modules => ["Hobo", "Dryml"], :method_name => "build_a" #, :class_name => "Dryml" 
+  
+    options = {:filters => composite_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal true, result, "Filter should allow passage"    
+  end
+      
+      
+  def test_composite_module_filter__module_not_match
+    composite_filter = Module_composite_filter_A
+  
+    context = {}    
+    context.set_context :modules => ['Blip', 'Blap']
+    
+    options = {:filters => composite_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal false, result, "Filter should NOT allow passage"    
+  end
+  
+  def test_composite_module_filter__method_excluded
+    composite_filter = Module_composite_filter_A
+  
+    context = {}    
+    context.set_context :modules => ["Hobo", "Dryml"], :method_name => "add_it"
+    
+    options = {:filters => composite_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal false, result, "Filter should NOT allow passage"    
+  end              
+end