trace-util-adv 0.2.4 → 0.3.0

data/test/extensions/test_set_context.rb

@@ -1,7 +1,4 @@
-require 'extensions/core_extensions'
-require 'filters/base_filters'
-require 'rules/hash_rule_extensions'
-require "test/unit"
+require "include"
 
 class Person
   attr_accessor :name
@@ -56,38 +53,39 @@ class TestHashExtensions < Test::Unit::TestCase
     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 = {
+      :block => true,
       :self => obj              
     }
-
+  
     assert_equal expected, context, "resulting @context not as expected"    
     assert_equal "Kristian", context[:self].name, "Kristian expected as person name"    
   end

data/test/extensions/test_string_extensions.rb

@@ -1,6 +1,4 @@
-require 'extensions/core_extensions'
-require "test/unit"
-
+require "include"
 
 class TestFilter < Test::Unit::TestCase
             

data/test/extensions/test_symbol_extensions.rb

@@ -1,6 +1,4 @@
-require 'extensions/core_extensions'
-require "test/unit"
-
+require 'include'
 
 class TestSymbolExtensions < Test::Unit::TestCase
 
@@ -18,7 +16,7 @@ class TestSymbolExtensions < Test::Unit::TestCase
   
   def test_trace_class
     result = :xml.trace_class
-    assert_equal result, Tracing::OutputTemplate::XmlTrace, ":xml Should result in XmlTrace"            
+    assert_equal result, Tracing::XmlTemplate, ":xml Should result in XmlTrace"            
   end
   
   def appender_class

data/test/filters/chain/test_filters_chain.rb

@@ -1,55 +1,5 @@
-require "core_extensions"
-require "trace_calls"
-require "output_templates"
-require "rubygems"
-require "duration"
-require "test/unit"
+require "../include"
 
-# configure use of TraceExt
-module Me
-  class My     
-
-    def hello
-      puts "Hello World!"
-    end   
-
-    def hi_there
-      puts "Hi there!"
-    end   
-
-    def blip
-      puts "Blip!"
-    end   
-
-    def blap
-      puts "Blap!"
-    end   
-
-  end    
-end
-
-Method_filter_A = {
-  :name => 'my methods',  
-  :method_rules => [{
-    # id of method rule set
-    :name => 'my_methods',
-    :include => [/hi.*/],
-    :exclude => ['hello'],
-    :default => :yield
-  }]
-}    
- 
-# Method_filter_B = {
-#   :name => 'my methods',  
-#   :method_rules => [{
-#     # id of method rule set
-#     :name => 'my_methods',
-#     :include => ['blip', 'blop'],
-#     :default => :yield
-#   }]
-# }
-
-  
 class TestFilter < Test::Unit::TestCase
 
   attr_reader :ah1, :filters

data/test/filters/composite/test_composite_class_filter.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 Class_composite_filter_A = {
   # id of composite rule set  

data/test/filters/composite/test_composite_module_filter.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 Module_composite_filter_A = {
   # id of composite rule set    

data/test/filters/composite/test_composite_var_filter.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 # for specific instance_vars, match on values (after .to_s on var)  
 
@@ -44,28 +42,28 @@ 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"    
+    assert_equal Tracing::ListInstanceVarFilter, 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"    
+    assert_equal Tracing::ListInstanceVarFilter, 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"    
+    assert_equal Tracing::ListInstanceVarFilter, 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'}
+    context = {:vars => ["template_path" => 'b/taglib/b'], :self => Obj.new('b/taglib/b')}.context
   
     options = {:filters => composite_filter}    
     exec = Tracing::Filter::Executor.new(options)       
@@ -76,8 +74,7 @@ class TestCompositeInstanceVarFilter < Test::Unit::TestCase
   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 = {:class_name => 'Blip::Blap', :vars => ["template_path" => 'rapid']}    
     context[:self] = Obj.new "blop"
     
     options = {:filters => composite_filter}    
@@ -90,7 +87,7 @@ class TestCompositeInstanceVarFilter < Test::Unit::TestCase
     composite_filter = Var_composite_filter
   
     context = {}    
-    context.set_context :class_name => 'Blip::Blap', :vars => ["template_path"]    
+    context.set_context :class_name => 'Blip::Blap', :vars => ["template_path" => 'blip']    
     context[:self] = Obj.new "a/rapid_x"
     
     options = {:filters => composite_filter}    

data/test/filters/executor/test_filter_exec.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 class TestFilterExec < Test::Unit::TestCase
 

data/test/filters/include.rb

@@ -0,0 +1,8 @@
+require "trace-util-adv"
+Require.base_path = File.dirname(__FILE__)
+Require.folder "../samples"
+require "test/unit"
+
+# b = Tracing::BaseFilter.register_filters({:hash => :C})
+# puts "B: #{b.inspect}"
+# puts Tracing::BaseFilter.filters.inspect

data/test/filters/msg_context/test_custom_filters.rb

@@ -1,12 +1,11 @@
-require 'core_extensions'
-require 'filters/base_filters'
-require 'filters/message_filters'
-
-
-require 'extensions/core_extensions'
-require "test/unit"
+require '../include'
 
 class CustomNameFilter < Tracing::NameFilter 
+  
+  def initialize(options)
+      super(options)
+  end
+  
   def allow?(name)
     name == options[:name]
   end    
@@ -18,7 +17,7 @@ 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')   
+    name_filter = CustomNameFilter.new({:name => '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
@@ -32,18 +31,18 @@ class TestSymbolExtensions < Test::Unit::TestCase
   end
             
   def test_custom_name_filter
-    res = @meth_filter_name.allow?("hello", @context)
-    assert_equal true, res, "Should allow since matching method name 'abc'"
+    res = @meth_filter_name.allow_action("hello", @context_abc)
+    assert_equal :yield, 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'"    
+    res = @meth_filter_abc.allow_action("hello", @context_rapid)
+    assert_equal :yield, 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'"    
+    res = @meth_filter_comb.allow_action("hello", @context_abc)
+    assert_equal :include, res, "Should allow since matching method name 'abc'"    
   end
     
 end

data/test/filters/simple/test_base_filter.rb

@@ -1,5 +1,4 @@
-require 'filters/base_filters'
-require "test/unit"
+require "../include"
 
 
 class TestBaseFilter < Test::Unit::TestCase
@@ -12,7 +11,7 @@ class TestBaseFilter < Test::Unit::TestCase
   end
             
   def test_default_name
-    bf = Tracing::BaseFilter.new
+    bf = Tracing::BaseFilter.new({})
     assert_equal "Unknown filter", bf.name, "Should result name:'Unknown filter'"
   end
   
@@ -26,12 +25,15 @@ class TestBaseFilter < Test::Unit::TestCase
     assert_equal "base", bf.name, "Should result in name:'base'"
   end
     
-  def test_register_filters    
-    bf = Tracing::BaseFilter.new({:name => 'base'})
+  def test_register_filters          
+    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"
+    expect = {:x => :y}    
+    assert_equal expect, bF.filters, "Should result in x=>y filter"
+
     f2 = {:z => :a}
     bF.register_filters(f2)
     expect = {:z=>:a, :x=>:y}

data/test/filters/simple/test_class_filter.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 Class_filter = {
   :name => 'my classes',  

data/test/filters/simple/test_instancevar_filter.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 InstanceVar_filter = {
   :name => 'check template path',
@@ -45,18 +43,19 @@ class TestInstanceVarFilter < Test::Unit::TestCase
   # 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
+    context = {:class_name => "Hobo::Dryml", :vars => {"template_path" => "a/taglib/x"}, :self => Obj.new("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    
+    context = {:class_name => 'Blip::Blap', :vars => {"template_path" => "a/taglib/x"}, :self => Obj.new("taglib/x") }.context    
     
     puts "Context:" + context.inspect
     
@@ -68,10 +67,7 @@ class TestInstanceVarFilter < Test::Unit::TestCase
   
   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"
-
+    context = {:class_name => 'Blip::Blap', :vars => {"template_path" => "a/taglib/x"}, :self => Obj.new("a/rapid_x") }.context  
     
     options = {:filters => var_filter}    
     exec = Tracing::Filter::Executor.new(options)       

data/test/filters/simple/test_method_filter.rb

@@ -1,6 +1,4 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 Method_filter = {
   :name => 'my methods',  
@@ -41,8 +39,7 @@ class TestMethodFilter < Test::Unit::TestCase
   def test_method_filter__class_and_method_match
     composite_filter = Method_filter
   
-    context = {}
-    context.set_context :class_name => "Hobo::Dryml", :method_name => "build_a"
+    context = { :class_name => "Hobo::Dryml", :method_name => "build_a"}.context
   
     options = {:filters => composite_filter}    
     exec = Tracing::Filter::Executor.new(options)       
@@ -53,8 +50,7 @@ class TestMethodFilter < Test::Unit::TestCase
   def test_method_filter__method_not_match
     composite_filter = Method_filter
   
-    context = {}    
-    context.set_context :class_name => 'Blip::Blap', :method_name => "blop"
+    context = { :class_name => 'Blip::Blap', :method_name => "blop"}.context
     
     options = {:filters => composite_filter}    
     exec = Tracing::Filter::Executor.new(options)       
@@ -65,8 +61,7 @@ class TestMethodFilter < Test::Unit::TestCase
   def test_method_filter__method_excluded
     composite_filter = Method_filter
   
-    context = {}    
-    context.set_context :class_name => "Hobo::Dryml", :method_name => "add_it"
+    context = { :class_name => "Hobo::Dryml", :method_name => "add_it"}.context
     
     options = {:filters => composite_filter}    
     exec = Tracing::Filter::Executor.new(options)       

data/test/filters/simple/test_module_filter.rb

@@ -1,17 +1,16 @@
-require 'filters/filter_exec'
-require 'extensions/core_extensions'
-require "test/unit"
+require "../include"
 
 Module_filter = {
   :name => 'my modules',
+  :default => :exclude,
   :module_rules => [{
     # id of modules rule set
     :name => ['my_modules'],
     :include => [/Hobo/],
     :exclude => [/Dryml/],
     :default => :exclude
-  }
-]}
+  }]
+}
 
 class TestModuleFilter < Test::Unit::TestCase
 
@@ -31,6 +30,7 @@ class TestModuleFilter < Test::Unit::TestCase
     _filter = Module_filter
     config = {:filters => _filter}    
     result = config.filters
+    puts result.inspect
     assert_equal Tracing::ModuleFilter, result.class, "Should result in  module filter"    
   end
 
@@ -38,8 +38,7 @@ class TestModuleFilter < Test::Unit::TestCase
   def test_module_filter__module_and_method_match
     _filter = Module_filter
   
-    context = {}
-    context.set_context :modules => ["Hobo"], :method_name => "build_a" #, :class_name => "Dryml" 
+    context = { :modules => ["Hobo"], :method_name => "build_a", :class_name => "Dryml" }.context
   
     options = {:filters => _filter}    
     exec = Tracing::Filter::Executor.new(options)       
@@ -47,16 +46,20 @@ class TestModuleFilter < Test::Unit::TestCase
     assert_equal true, result, "Filter should allow passage"    
   end
       
-      
+  # TODO: Doesn't Work :(
   def test_module_filter__module_not_match
     _filter = Module_filter
   
-    context = {}    
-    context.set_context :modules => ['Blip', 'Blap']
+    context = {:modules => ["Blip", "Blop"], :method_name => "build_a", :class_name => "Dryml"}.context
+    
+    puts context.inspect
     
     options = {:filters => _filter}    
     exec = Tracing::Filter::Executor.new(options)       
     result = exec.filters_allow?('msg', context)
+  
+    puts "Result:" + result.inspect  
+  
     assert_equal false, result, "Filter should NOT allow passage"    
   end