log4r 1.0.6

data/tests/testconf.xml

@@ -0,0 +1,37 @@
+<test>
+<log4r_config>
+
+  <pre_config>
+    <custom_levels>Foo, Bar,Baz, Bing</custom_levels>
+    <global level="Foo"/>
+    <parameters>
+      <mypattern>[%l] %d %t - %m</mypattern>
+    </parameters>
+    <parameter name="datem" value="usec"/>
+  </pre_config>
+
+  <!-- level and formatter are optional, -->
+  <outputter name="SO" type="StdoutOutputter">
+    <level>Foo</level>
+    <formatter type="Log4r::PatternFormatter">
+      <pattern>%d %c %l&gt; %m</pattern>
+      <date_method>#{datem}</date_method>
+    </formatter>
+  </outputter>
+  <outputter name="SE" type="StderrOutputter" level="Baz">
+    <formatter type="PatternFormatter" pattern="#{mypattern}">
+      <date_pattern>%H:%S</date_pattern>
+    </formatter>
+  </outputter>
+  <outputter name="F" type="FileOutputter">
+    <filename>#{logpath}/junk/foo.log</filename>
+    <trunc>true</trunc>
+    <only_at>Foo, Bar, Bing</only_at>
+  </outputter>
+  <!-- optional level, additive and outputters -->
+  <logger name="first::second" level="Bar" additive="false">
+    <trace>true</trace>
+    <outputters>SO, SE, F, stdout, stderr</outputters>
+  </logger>
+</log4r_config>
+</test>

data/tests/testcustom.rb

@@ -0,0 +1,27 @@
+
+# tests the customization of Log4r levels
+class TestCustom < TestCase
+  def test_validation
+    assert_exception(TypeError) { Configurator.custom_levels "lowercase" }
+    assert_exception(TypeError) { Configurator.custom_levels "With space" }
+  end
+
+  def test_create
+    assert_no_exception { Configurator.custom_levels "Foo", "Bar", "Baz" }
+    assert_no_exception { Configurator.custom_levels }
+    assert_no_exception { Configurator.custom_levels "Bogus", "Levels" }
+  end
+  def test_methods
+    l = Logger.new 'custom1'
+    assert_respond_to(:foo, l)
+    assert_respond_to(:foo?, l)
+    assert_respond_to(:bar, l)
+    assert_respond_to(:bar?, l)
+    assert_respond_to(:baz, l)
+    assert_respond_to(:baz?, l)
+    assert_no_exception(NameError) { Bar }
+    assert_no_exception(NameError) { Baz }
+    assert_no_exception(NameError) { Foo }
+  end
+    
+end

data/tests/testformatter.rb

@@ -0,0 +1,27 @@
+class TestFormatter < TestCase
+  def test_creation
+    assert_no_exception { Formatter.new.format(3) }
+    assert_no_exception { DefaultFormatter.new }
+    assert_kind_of(Formatter, DefaultFormatter.new)
+  end
+  def test_simple_formatter
+    sf = SimpleFormatter.new
+    f = Logger.new('simple formatter')
+    event = LogEvent.new(0, f, nil, "some data")
+    assert_match(sf.format(event), /simple formatter/)
+  end
+  def test_basic_formatter
+    b = BasicFormatter.new
+    f = Logger.new('fake formatter')
+    event = LogEvent.new(0, f, caller, "fake formatter")
+    event2 = LogEvent.new(0, f, nil, "fake formatter")
+    # this checks for tracing
+    assert_match(b.format(event), /in/)
+    assert_not_match(b.format(event2), /in/)
+    e = ArgumentError.new("argerror")
+    e.set_backtrace ['backtrace']
+    event3 = LogEvent.new(0, f, nil, e)
+    assert_match(b.format(event3), /ArgumentError/)
+    assert_match(b.format(LogEvent.new(0,f,nil,[1,2,3])), /Array/)
+  end
+end 

data/tests/testlogger.rb

@@ -0,0 +1,196 @@
+class MyFormatter1 < Formatter
+  def format(event)
+    return "MyFormatter1\n"
+  end
+end
+
+class MyFormatter2 < Formatter
+  def format(event)
+    return "MyFormatter2\n"
+  end
+end
+
+class TestLogger < TestCase
+  def test_root
+    l1 = Logger.root
+    l2 = Logger['root']
+    l3 = Logger.global
+    assert(l1 == l2, "RootLogger wasn't singleton!")
+    assert(l1 == l3)
+    assert(l1.is_root? == true, "is_root? not working")
+    assert(l1.parent == nil, "Root's parent wasn't nil!")
+  end
+  def test_validation
+    assert_exception(ArgumentError) { Logger.new }
+    assert_no_exception { Logger.new('validate', nil) }
+  end
+  def test_all_off
+    l = Logger.new("create_method")
+    l.level = WARN
+    assert(l.debug? == false)
+    assert(l.info? == false)
+    assert(l.warn? == true)
+    assert(l.error? == true)
+    assert(l.fatal? == true)
+    assert(l.off? == false)
+    assert(l.all? == false)
+    l.level = OFF
+    assert(l.off? == true)
+    assert(l.all? == false)
+    l.level = ALL
+    assert(l.off? == false)
+    assert(l.all? == true)
+  end
+  def test_add_outputters
+    StdoutOutputter.new('fake1')
+    StdoutOutputter.new('fake2')
+    a = Logger.new("add")
+    assert_exception(TypeError) { a.add 'bogus' }
+    assert_exception(TypeError) { a.add Class }
+    assert_exception(TypeError) { a.add 'fake1', Class }
+    assert_no_exception { a.add 'fake1', 'fake2' }
+  end
+  def test_repository
+    assert_exception(NameError) { Logger.get('bogusbogus') }
+    assert_no_exception { Logger['bogusbogus'] }
+  end
+  def test_heiarchy
+    a = Logger.new("a")
+    a.additive = true
+    assert(a.name == "a", "name wasn't set properly")
+    assert(a.path == "", "path wasn't set properly")
+    assert(a.level == Logger.root.level, "didn't inherit root's level") 
+    assert(a.parent == Logger.root)
+    a.level = WARN
+    b = Logger.new("a::b")
+    assert(b.name == "b", "name wasn't set properly")
+    assert(b.path == "a", "path wasn't set properly")
+    assert(b.level == a.level, "didn't inherit parent's level") 
+    assert(b.parent == a, "parent wasn't what is expected")
+    c = Logger.new("a::b::c")
+    assert(Logger["a::b::c"] == c)
+    assert(c.name == "c", "name wasn't set properly")
+    assert(c.path == "a::b", "path wasn't set properly")
+    assert(c.level == b.level, "didn't inherit parent's level") 
+    assert(c.parent == b, "parent wasn't what is expected")
+    d = Logger.new("a::d")
+    assert(Logger["a::d"] == d)
+    assert(d.name == "d", "name wasn't set properly")
+    assert(d.path == "a", "path wasn't set properly")
+    assert(d.level == a.level, "didn't inherit parent's level") 
+    assert(d.parent == a, "parent wasn't what is expected")
+    assert_exception(ArgumentError) { Logger.new("::a") }
+  end
+  def test_undefined_parents
+    a = Logger.new 'has::no::real::parents::me'
+    assert(a.parent == Logger.root)
+    b = Logger.new 'has::no::real::parents::me::child'
+    assert(b.parent == a)
+    c = Logger.new 'has::no::real::parents::metoo'
+    assert(c.parent == Logger.root)
+    p = Logger.new 'has::no::real::parents'
+    assert(p.parent == Logger.root)
+    assert(a.parent == p)
+    assert(b.parent == a)
+    assert(c.parent == p)
+    Logger.each{|fullname, logger|
+      if logger != a and logger != c
+        assert(logger.parent != p)
+      end
+    }
+  end
+  def test_levels
+    l = Logger.new("levels", WARN)
+    assert(l.level == WARN, "level wasn't changed")
+    assert(l.fatal? == true)
+    assert(l.error? == true)
+    assert(l.warn? == true)
+    assert(l.info? == false)
+    assert(l.debug? == false)
+    l.debug "debug message should NOT show up"
+    l.info "info message should NOT show up"
+    l.warn "warn messge should show up. 3 total"
+    l.error "error messge should show up. 3 total"
+    l.fatal "fatal messge should show up. 3 total"
+    l.level = ERROR
+    assert(l.level == ERROR, "level wasn't changed")
+    assert(l.fatal? == true)
+    assert(l.error? == true)
+    assert(l.warn? == false)
+    assert(l.info? == false)
+    assert(l.debug? == false)
+    l.debug "debug message should NOT show up"
+    l.info "info message should NOT show up"
+    l.warn "warn messge should NOT show up."
+    l.error "error messge should show up. 2 total"
+    l.fatal "fatal messge should show up. 2 total"
+    l.level = WARN
+  end
+  def test_log_blocks
+    l = Logger.new 'logblocks'
+    l.level = WARN
+    l.add(Outputter.stdout)
+    assert_no_exception {
+      l.debug { puts "should not show up"; "LOGBLOCKS" }
+      l.fatal { puts "should show up"; "LOGBLOCKS" }
+      l.fatal { nil }
+      l.fatal {}
+    }
+  end
+  def test_heiarchial_logging
+    a = Logger.new("one")
+    a.add(StdoutOutputter.new 'so1')
+    b = Logger.new("one::two")
+    b.add(StdoutOutputter.new 'so2')
+    c = Logger.new("one::two::three")
+    c.add(StdoutOutputter.new 'so3')
+    d = Logger.new("one::two::three::four")
+    d.add(StdoutOutputter.new 'so4')
+    d.additive = false
+    e = Logger.new("one::two::three::four::five")
+    e.add(StdoutOutputter.new 'so5')
+
+    a.fatal "statement from a should show up once"
+    b.fatal "statement from b should show up twice"
+    c.fatal "statement from c should show up thrice"
+    d.fatal "statement from d should show up once"
+    e.fatal "statement from e should show up twice"
+  end
+  def test_multi_outs
+    f1 = FileOutputter.new('f1', :filename => "./junk/tmp1.log", :level=>ALL)
+    f2 = FileOutputter.new('f2', :filename => "./junk/tmp2.log", :level=>DEBUG)
+    f3 = FileOutputter.new('f3', :filename => "./junk/tmp3.log", :level=>ERROR)
+    f4 = FileOutputter.new('f4', :filename => "./junk/tmp4.log", :level=>FATAL)
+
+    l = Logger.new("multi")
+    l.add(f1, f3, f4)
+
+    a = Logger.new("multi::multi2")
+    a.level = ERROR
+    a.add(f2, f4)
+    
+    l.debug "debug test_multi_outputters"
+    l.info "info test_multi_outputters"
+    l.warn "warn test_multi_outputters"
+    l.error "error test_multi_outputters"
+    l.fatal "fatal test_multi_outputters"
+
+    a.debug "debug test_multi_outputters"
+    a.info "info test_multi_outputters"
+    a.warn "warn test_multi_outputters"
+    a.error "error test_multi_outputters"
+    a.fatal "fatal test_multi_outputters"
+    
+    f1.close; f2.close; f3.close; f4.close
+  end
+  def test_custom_formatter
+    l = Logger.new('custom_formatter')
+    o = StdoutOutputter.new('formatter'=>MyFormatter1.new)
+    l.add o
+    l.error "try myformatter1"
+    l.fatal "try myformatter1"
+    o.formatter = MyFormatter2.new
+    l.error "try formatter2"
+    l.fatal "try formatter2"
+  end
+end 

data/tests/testoutputter.rb

@@ -0,0 +1,111 @@
+
+class TestOutputter < TestCase
+  def test_validation
+    assert_exception(ArgumentError) { Outputter.new }
+    assert_exception(ArgumentError) { Outputter.new 'fonda', :level=>-10}
+    assert_exception(TypeError) { Outputter.new 'fonda', :formatter=>-10}
+  end
+  def test_io
+    assert_no_exception {
+      IOOutputter.new('foo3', $stdout)
+      IOOutputter.new('foo4', $stderr)
+    }
+    f = File.new("junk/tmpx.log", "w")
+    o = IOOutputter.new('asdf', f)
+    o.close
+    assert(f.closed? == true)
+    assert(o.level == OFF)
+  end
+  def test_repository
+    assert( Outputter['foo3'].type == IOOutputter )
+    assert( Outputter['foo4'].type == IOOutputter )
+    assert( Outputter['asdf'].type == IOOutputter )
+  end
+  def test_validation_and_creation
+    assert_no_exception {
+      StdoutOutputter.new('out', 'level'=>DEBUG)
+      FileOutputter.new('file', 'filename'=>'junk/test', :trunc=>true)
+    }
+    a = StdoutOutputter.new 'out2'
+    assert(a.level == Logger.root.level)
+    assert(a.formatter.type == DefaultFormatter)
+    b = StdoutOutputter.new('ook', :level => DEBUG, :formatter => Formatter)
+    assert(b.level == DEBUG)
+    assert(b.formatter.type == Formatter)
+    c = StdoutOutputter.new('akk', :formatter => Formatter)
+    assert(c.level == Logger.root.level)
+    assert(c.formatter.type == Formatter)
+    c = StderrOutputter.new('iikk', :level => OFF)
+    assert(c.level == OFF)
+    assert(c.formatter.type == DefaultFormatter)
+    o = StderrOutputter.new 'ik'
+    assert_no_exception(TypeError) { o.formatter = DefaultFormatter }
+    assert_equals(o.formatter.type, DefaultFormatter)
+  end
+  # test the resource= bounds
+  def test_boundaries
+    o = StderrOutputter.new('ak', :formatter => Formatter)
+    assert_exception(TypeError) { o.formatter = nil }
+    assert_exception(TypeError) { o.formatter = String }
+    assert_exception(TypeError) { o.formatter = "bogus" }
+    assert_exception(TypeError) { o.formatter = -3 }
+    # the formatter should be preserved
+    assert(o.formatter.type == Formatter) 
+  end
+  def test_file
+    assert_exception(TypeError) { FileOutputter.new 'f' }
+    assert_exception(TypeError) { FileOutputter.new('fa', :filename => DEBUG) }
+    assert_exception(TypeError) { FileOutputter.new('fo', :filename => nil) }
+    assert_no_exception { 
+      FileOutputter.new('fi', :filename => './junk/tmp')
+      FileOutputter.new('fum', :filename=>'./junk/tmp', :trunc => "true")
+    }
+    fo = FileOutputter.new('food', :filename => './junk/tmp', :trunc => false)
+    assert(fo.trunc == false)
+    assert(fo.filename == './junk/tmp')
+    assert(fo.closed? == false)
+    fo.close
+    assert(fo.closed? == true)
+    assert(fo.level == OFF)
+  end
+  # test the dynamic definition of outputter log messages
+  def test_log_methods
+    o = StderrOutputter.new('so1', :level => WARN )
+    # test to see if all of the methods are defined
+    for mname in LNAMES
+      next if mname == 'OFF' || mname == 'ALL'
+      assert_respond_to(mname.downcase, o, "Test respond to #{mname.to_s}")
+    end 
+    return # cuz the rest is borked
+    # we rely on BasicFormatter's inability to reference a nil Logger to test
+    # the log methods. Everything from WARN to FATAL should choke.
+    event = LogEvent.new(nil, nil, nil, nil) 
+    assert_no_exception { o.debug event }
+    assert_no_exception { o.info event }
+    assert_exception(NameError) { o.warn event }
+    assert_exception(NameError) { o.error event }
+    assert_exception(NameError) { o.fatal event }
+    # now let's dynamically change the level and repeat
+    o.level = ERROR
+    assert_no_exception { o.debug event}
+    assert_no_exception { o.info event}
+    assert_no_exception { o.warn event}  
+    assert_exception(NameError) { o.error event}
+    assert_exception(NameError) { o.fatal event}
+  end
+  def test_only_at_validation
+    o = StdoutOutputter.new 'so2'
+    assert_exception(ArgumentError) { o.only_at }
+    assert_exception(ArgumentError) { o.only_at ALL }
+    assert_exception(TypeError) { o.only_at OFF }
+    assert_no_exception { o.only_at DEBUG, ERROR }
+    return # cuz the rest is borked
+    # test the methods as before
+    event = LogEvent.new(nil,nil,nil,nil)
+    assert_exception(NameError) { o.debug event}
+    assert_exception(NameError) { o.error event}
+    assert_no_exception { o.warn event}
+    assert_no_exception { o.info event}
+    assert_no_exception { o.fatal event}
+  end
+end 

data/tests/testpatternformatter.rb

@@ -0,0 +1,21 @@
+class TestPatternFormatter < TestCase
+  def test_pattern
+    l = Logger.new 'test::this::that'
+    l.trace = true
+    o = StdoutOutputter.new 'test' 
+    l.add o
+    assert_no_exception { 
+    f = PatternFormatter.new :pattern=> "%d %6l [%C]%c %% %-40.30M"
+                             #:date_pattern=> "%Y"
+                             #:date_method => :usec
+    Outputter['test'].formatter = f
+    l.debug "And this?"
+    l.info "How's this?"
+    l.error "and a really freaking huge line which we hope will be trimmed?"
+    e = ArgumentError.new("something barfed")
+    e.set_backtrace Array.new(5, "trace junk at thisfile.rb 154")
+    l.fatal e
+    l.info [1, 3, 5]
+    }
+  end
+end

data/tests/testxmlconf.rb

@@ -0,0 +1,45 @@
+
+One=<<-EOX
+<log4r_config><pre_config><custom_levels> Foo </custom_levels>
+</pre_config></log4r_config>
+EOX
+Two=<<-EOX
+<log4r_config><pre_config><global level="DEBUG"/></pre_config></log4r_config>
+EOX
+Three=<<-EOX
+<log4r_config><pre_config><custom_levels>Foo</custom_levels>
+<global level="Foo"/></pre_config>
+</log4r_config>
+EOX
+
+# must be run independently
+class TestXmlConf < TestCase
+  def test_load1
+    Configurator.load_xml_string(One)
+    assert_no_exception{ 
+      assert(Foo == 1) 
+      assert(Logger.global.level == ALL)
+    }
+  end
+  def test_load2
+    Configurator.load_xml_string(Two)
+    assert_no_exception{ 
+      assert(Logger.global.level == DEBUG)
+    }
+  end
+  def test_load3
+    Configurator.load_xml_string(Three)
+    assert_no_exception{ 
+      assert(Foo == 1) 
+      assert(Logger.global.level == Foo)
+    }
+  end
+  def test_load4
+    assert_no_exception {
+      Configurator['logpath'] = '.'
+      Configurator.load_xml_file "xml/testconf.xml"
+      a = Logger['first::second']
+      a.bing "what the heck"
+    }
+  end
+end