trace-util-adv 0.2.3 → 0.2.4

data/test/filters/composite/test_composite_var_filter.rb

@@ -0,0 +1,103 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+# for specific instance_vars, match on values (after .to_s on var)  
+
+# include if @template_path MATCHES 'taglib'
+# exclude if @template_path MATCHES 'rapid_'
+# exclude if @builder MATCHES 'bad_'
+Var_composite_filter = {
+  :name => 'template_path',
+  :default => :exclude,  
+  :vars => [
+  # include if @template_path MATCHES 'taglib'
+  # exclude if @template_path MATCHES 'rapid_'    
+  {
+    :name => 'template_path',
+    :var_rules => {
+      :include => [/.*\/taglib\/.*/], 
+      :exclude => [/.*\/rapid_.*/],       
+      :default => :exclude_and_yield
+    } 
+  },
+  # exclude if @builder MATCHES 'bad_'  
+  {
+  :name => 'builder', 
+    :var_rules => {
+      :exclude => [/.*\/bad.*/],         
+      :default => :include
+    } 
+  }]
+}
+
+class Obj
+  attr_accessor :template_path
+  
+  def initialize(value = nil)
+    @template_path = value  
+  end
+end
+
+class TestCompositeInstanceVarFilter < Test::Unit::TestCase
+
+  def test_composite_var_filter_hash_to_var
+    composite_filter = Var_composite_filter
+    result = composite_filter.filter_class
+    assert_equal Tracing::CompositeInstanceVarFilter, result, "Should result in composite var filter"    
+  end
+
+  def test_composite_var_filter_hash_to_var
+    composite_filter = Var_composite_filter
+    result = composite_filter.create_filter
+    assert_equal Tracing::CompositeInstanceVarFilter, result.class, "Should result in composite var filter"    
+  end  
+  
+  def test_composite_var_filter_from_hash
+    composite_filter = Var_composite_filter
+    config = {:filters => composite_filter}    
+    result = config.filters
+    assert_equal Tracing::CompositeInstanceVarFilter, result.class, "Should result in composite var filter"    
+  end
+
+  # see allow_action in CompositeInstanceVarFilter, refactor :yield, :include .. as return values!?
+  def test_composite_var_filter__var_and_method_match
+    composite_filter = Var_composite_filter
+  
+    context = {}
+    context.set_context :vars => {:template_path => 'rapid'}
+  
+    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_var_filter__var_not_match
+    composite_filter = Var_composite_filter
+  
+    context = {}    
+    context.set_context :class_name => 'Blip::Blap', :vars => ["template_path"]    
+    context[:self] = Obj.new "blop"
+    
+    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_var_filter__method_excluded
+    composite_filter = Var_composite_filter
+  
+    context = {}    
+    context.set_context :class_name => 'Blip::Blap', :vars => ["template_path"]    
+    context[:self] = Obj.new "a/rapid_x"
+    
+    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/executor/test_filter_exec.rb

@@ -0,0 +1,80 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+class TestFilterExec < Test::Unit::TestCase
+
+  def setup
+    @context = {:class_name => "Alpha::Beta::Gamma", :method_name => "meth_a", :vars => {:template_path => 'rapid'}, :args => {:a => 7} }.context
+  end
+
+  def teardown
+    ## Nothing really
+  end
+
+  # include method
+  def test_single_filter_allow
+    im_filter = {:i_method_filter => "meth_b, meth_a"} 
+    options = {:filters => im_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', @context)
+    assert_equal true, result, "Filter should allow passage"    
+  end
+  
+
+  # exclude method
+  def test_single_filter_not_allow
+    xm_filter = {:x_method_filter => "meth_b, meth_a"} 
+    options = {:filters => xm_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', @context)
+    assert_equal false, result, "Filter should not allow passage"    
+  end
+
+  # yield include
+  def test_single_filter_yield_include
+    xm_filter = {:x_method_filter => "meth_b, meth_c"} 
+    options = {:filters => xm_filter, :final_yield_action => :include}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', @context)
+    assert_equal true, result, "Filter should not allow passage"    
+  end
+
+  def test_single_filter_yield_exclude
+    xm_filter = {:x_method_filter => "meth_b, meth_c"} 
+    options = {:filters => xm_filter, :final_yield_action => :exclude}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', @context)
+    assert_equal false, result, "Filter should not allow passage"    
+  end
+
+  def test_single_filter_yield_exclude_default
+    xm_filter = {:x_method_filter => "a,b"} 
+    # :final_yield_action => :exclude by default
+    options = {:filters => xm_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_two_filters
+    im_filter = {:i_method_filter => "meth_b, meth_a"} 
+    xm_filter = {:x_method_filter => "a,b"} 
+    options = {:filters => [im_filter, xm_filter] }    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', @context)
+    assert_equal true, result, "Should allow passage"
+  end
+  
+  def test_two_yield_filters
+    iy_filter = {:iy_method_filter => "meth_b, meth_a"} 
+    xy_filter = {:xy_method_filter => "meth_b, meth_c"} 
+    options = {:filters => [iy_filter, xy_filter]}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', @context)
+    assert_equal true, result, "Should allow passage"
+  end
+
+  
+end
+

data/test/filters/msg_context/test_custom_filters.rb

@@ -0,0 +1,54 @@
+require 'core_extensions'
+require 'filters/base_filters'
+require 'filters/message_filters'
+
+
+require 'extensions/core_extensions'
+require "test/unit"
+
+class CustomNameFilter < Tracing::NameFilter 
+  def allow?(name)
+    name == options[:name]
+  end    
+end
+
+
+class TestSymbolExtensions < Test::Unit::TestCase
+
+  def setup
+    # Procs of this form can be used as filters inside include/exclude lists
+    abc_filter = Proc.new {|name| name == 'abc' }
+    name_filter = CustomNameFilter.new('rapid')   
+    @meth_filter_abc = {:i_method_filter => [abc_filter], :default => :exclude}.filters
+    @meth_filter_name = {:i_method_filter => [name_filter], :default => :exclude}.filters
+    @meth_filter_comb = {:i_method_filter => [abc_filter, name_filter], :default => :exclude}.filters
+    
+    @context_abc = {:modules => ["Hobo"], :class_name => "Dryml", :method_name => "abc"}.context
+    @context_rapid = {:modules => ["Hobo"], :class_name => "Dryml", :method_name => "rapid"}.context    
+  end
+
+  def teardown
+    ## Nothing really
+  end
+            
+  def test_custom_name_filter
+    res = @meth_filter_name.allow?("hello", @context)
+    assert_equal true, res, "Should allow since matching method name 'abc'"
+  end
+
+  def test_custom_proc_filter
+    res = @meth_filter_abc.allow?("hello", @context)
+    assert_equal true, res, "Should allow since matching method name 'rapid'"    
+  end
+
+  def test_custom_filters
+    @meth_filter_comb.allow?("hello", @context)
+    assert_equal true, res, "Should allow since matching method name 'abc'"    
+  end
+    
+end
+
+
+
+
+ 

data/test/filters/simple/test_base_filter.rb

@@ -0,0 +1,56 @@
+require 'filters/base_filters'
+require "test/unit"
+
+
+class TestBaseFilter < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+    ## Nothing really
+  end
+            
+  def test_default_name
+    bf = Tracing::BaseFilter.new
+    assert_equal "Unknown filter", bf.name, "Should result name:'Unknown filter'"
+  end
+  
+  def test_create_w_name
+    bf = Tracing::BaseFilter.new({:name => 'base'})
+    assert_equal "base", bf.name, "Should result in name:'base'"
+  end
+
+  def test_create_w_name
+    bf = Tracing::BaseFilter.new({:name => 'base'})
+    assert_equal "base", bf.name, "Should result in name:'base'"
+  end
+    
+  def test_register_filters    
+    bf = Tracing::BaseFilter.new({:name => 'base'})
+    bF = Tracing::BaseFilter
+    f1 = {:x => :y}
+    bF.register_filters(f1)
+    assert_equal f1, bF.filters, "Should result in x=>y filter"
+    f2 = {:z => :a}
+    bF.register_filters(f2)
+    expect = {:z=>:a, :x=>:y}
+    assert_equal expect, bF.filters, "Should result in x=>y and z=>a filter"        
+  end
+  
+  def test_unregister_filters    
+    bf = Tracing::BaseFilter.new({:name => 'base'})
+    bF = Tracing::BaseFilter
+    # clear old filters
+    bF.filters = {}
+    f1 = {:x => :y}
+    bF.unregister_filters(f1)
+    assert_equal({}, bF.filters, "Should result in empty filter")
+    f2 = {:z => :a, :x => :y}
+    bF.register_filters(f2)
+    bF.unregister_filters(f1)
+    expect = {:z=>:a}
+    assert_equal expect, bF.filters, "Should result in z=>a filter"        
+  end
+  
+end

data/test/filters/simple/test_class_filter.rb

@@ -0,0 +1,75 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+Class_filter = {
+  :name => 'my classes',  
+  :class_rules => [{
+    # id of class rule set
+    :name => 'my_classes',
+    :include => [/Dryml/],
+    :exclude => [/NotMy/],
+    :default => :yield
+  }]
+}
+
+class TestFilter < Test::Unit::TestCase
+
+  def test_class_filter_hash_to_class
+    class_filter = Class_filter
+    result = class_filter.filter_class
+    assert_equal Tracing::ClassFilter, result, "Should result in  class filter"    
+  end
+
+  def test_class_filter_hash_to_class
+    class_filter = Class_filter
+    result = class_filter.create_filter
+    assert_equal Tracing::ClassFilter, result.class, "Should result in  class filter"    
+  end
+  
+  
+  def test_class_filter_from_hash
+    class_filter = Class_filter
+    config = {:filters => class_filter}    
+    result = config.filters
+    assert_equal Tracing::ClassFilter, result.class, "Should result in method filter"    
+  end
+
+  # see allow_action in ClassFilter, refactor :yield, :include .. as return values!?
+  def test_class_filter__class_and_method_match
+    class_filter = Class_filter
+  
+    context = {}
+    context.set_context :class_name => "Dryml", :method_name => "build_a"
+  
+    options = {:filters => class_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal true, result, "Filter should allow passage"    
+  end
+
+  def test_class_filter__class_not_match
+    class_filter = Class_filter
+  
+    context = {}    
+    context.set_context :class_name => 'Blip::Blap'
+    
+    options = {:filters => class_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_class_filter__method_excluded
+    class_filter = Class_filter
+  
+    context = {}    
+    context.set_context :class_name => "Hobo::Blip"
+    
+    options = {:filters => class_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/simple/test_instancevar_filter.rb

@@ -0,0 +1,82 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+InstanceVar_filter = {
+  :name => 'check template path',
+  :var_name => 'template_path',
+  :var_rules => {
+    :include => [/.*\/taglib\/.*/], 
+    :exclude => [/.*\/rapid_.*/],
+    :default => :exclude         
+  }
+}
+
+class Obj
+  attr_accessor :template_path
+  
+  def initialize(value = nil)
+    @template_path = value  
+  end
+end
+
+class TestInstanceVarFilter < Test::Unit::TestCase
+
+  def test_varfilter_hash_to_class
+    var_filter = InstanceVar_filter
+    result = var_filter.filter_class
+    assert_equal Tracing::InstanceVarFilter, result, "Should result in var filter"    
+  end
+
+  def test_varfilter_hash_to_class
+    var_filter = InstanceVar_filter
+    result = var_filter.create_filter
+    assert_equal Tracing::InstanceVarFilter, result.class, "Should result in var filter"    
+  end
+  
+  
+  def test_varfilter_from_hash
+    var_filter = InstanceVar_filter
+    config = {:filters => var_filter}    
+    result = config.filters
+    assert_equal Tracing::InstanceVarFilter, result.class, "Should result in var filter"    
+  end
+
+  # see allow_action in InstanceVarFilter, refactor :yield, :include .. as return values!?
+  def test_varfilter__class_and_varmatch
+    var_filter = InstanceVar_filter
+    context = {:class_name => "Hobo::Dryml", :vars => {"template_path" => "a/taglib/x"} }.context
+  
+    options = {:filters => var_filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal true, result, "Filter should allow passage"    
+  end
+
+  def test_varfilter__varnot_match
+    var_filter = InstanceVar_filter
+  
+    context = {:class_name => 'Blip::Blap', :vars => {"template_path" => "a/taglib/x"}, :self => Obj.new("blop") }.context    
+    
+    puts "Context:" + context.inspect
+    
+    options = {:filters => var_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_varfilter__varexcluded
+    var_filter = InstanceVar_filter
+    context = {:class_name => 'Blip::Blap', :vars => {"template_path" => "a/taglib/x"} }.context
+    
+    context[:self] = Obj.new "a/rapid_x"
+
+    
+    options = {:filters => var_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/simple/test_method_filter.rb

@@ -0,0 +1,77 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+Method_filter = {
+  :name => 'my methods',  
+  :method_rules => [{
+    # id of method rule set
+    :name => 'my_methods',
+    :include => [/by.*/, 'build_a', 'do_it'],
+    :exclude => ['add.*'],
+    :exclude_and_yield => ['blip'],
+    :default => :exclude
+  }]
+}
+
+
+class TestMethodFilter < Test::Unit::TestCase
+
+  def test_method_filter_hash_to_class
+    composite_filter = Method_filter
+    result = composite_filter.filter_class
+    assert_equal Tracing::MethodFilter, result, "Should result in method filter"    
+  end
+
+  def test_method_filter_hash_to_class
+    composite_filter = Method_filter
+    result = composite_filter.create_filter
+    assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
+  end
+  
+  
+  def test_method_filter_from_hash
+    composite_filter = Method_filter
+    config = {:filters => composite_filter}    
+    result = config.filters
+    assert_equal Tracing::MethodFilter, result.class, "Should result in method filter"    
+  end
+
+  # see allow_action in MethodFilter, refactor :yield, :include .. as return values!?
+  def test_method_filter__class_and_method_match
+    composite_filter = Method_filter
+  
+    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_method_filter__method_not_match
+    composite_filter = Method_filter
+  
+    context = {}    
+    context.set_context :class_name => 'Blip::Blap', :method_name => "blop"
+    
+    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_method_filter__method_excluded
+    composite_filter = Method_filter
+  
+    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/simple/test_module_filter.rb

@@ -0,0 +1,63 @@
+require 'filters/filter_exec'
+require 'extensions/core_extensions'
+require "test/unit"
+
+Module_filter = {
+  :name => 'my modules',
+  :module_rules => [{
+    # id of modules rule set
+    :name => ['my_modules'],
+    :include => [/Hobo/],
+    :exclude => [/Dryml/],
+    :default => :exclude
+  }
+]}
+
+class TestModuleFilter < Test::Unit::TestCase
+
+  def test_module_filter_hash_to_module
+    _filter = Module_filter
+    result = _filter.filter_module
+    assert_equal Tracing::ModuleFilter, result, "Should result in  module filter"    
+  end
+
+  def test_module_filter_hash_to_module
+    _filter = Module_filter
+    result = _filter.create_filter
+    assert_equal Tracing::ModuleFilter, result.class, "Should result in  module filter"    
+  end
+
+  def test_module_filter_from_hash
+    _filter = Module_filter
+    config = {:filters => _filter}    
+    result = config.filters
+    assert_equal Tracing::ModuleFilter, result.class, "Should result in  module filter"    
+  end
+
+  # see allow_action in ModuleFilter, refactor :yield, :include .. as return values!?
+  def test_module_filter__module_and_method_match
+    _filter = Module_filter
+  
+    context = {}
+    context.set_context :modules => ["Hobo"], :method_name => "build_a" #, :class_name => "Dryml" 
+  
+    options = {:filters => _filter}    
+    exec = Tracing::Filter::Executor.new(options)       
+    result = exec.filters_allow?('msg', context)
+    assert_equal true, result, "Filter should allow passage"    
+  end
+      
+      
+  def test_module_filter__module_not_match
+    _filter = Module_filter
+  
+    context = {}    
+    context.set_context :modules => ['Blip', 'Blap']
+    
+    options = {:filters => _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/samples/include.rb

@@ -0,0 +1 @@
+Dir.glob(File.join(File.dirname(__FILE__), '**/*.rb')).each {|f| require f }

data/test/samples/sample_classes.rb

@@ -0,0 +1,23 @@
+# configure use of TraceExt
+module Me
+  class My     
+
+    def hello
+      puts "Hello cruel World!"
+    end   
+
+    def hi_there
+      puts "Hello cruel World!"
+    end   
+
+    def blip
+      puts "Blip!"
+    end   
+
+    def blap
+      puts "Blap!"
+    end   
+
+  end    
+end
+

data/test/samples/sample_composite_filters.rb

@@ -0,0 +1,50 @@
+Class_composite_filter_A = {
+  # id of composite rule set  
+  :name => 'Template stuff',
+  :classes => [{
+    :names => ['My', /My/],
+    :method_rules => {
+      :include => [/by.*/, 'DRYMLBuilder'],
+      :exclude => ['Taglib'],
+      :default => :exclude
+    }
+  }]
+}
+
+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 => [/Template.*/, 'DRYMLBuilder'],
+      :exclude => ['Taglib'],
+      :default => :include
+    }
+  }]
+}
+
+
+# for specific instance_vars, match on values (after .to_s on var)  
+Var_composite_filter_A = {
+  :name => 'template_path',
+  :vars => [{
+    :name => 'template_path', :type => :string,
+    :var_rules => {
+      :include => [/.*\/taglib\/.*/], 
+      :exclude => [/.*\/rapid_.*/]         
+    } 
+    },
+    {
+      :name => 'template_path', 
+      :var_rules => {
+        :exclude => [/.*\/rapid_.*/],         
+        :default => :include
+      } 
+    }]
+}