mtn_log4r 1.1.11

data/tests/testlogger.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+
+class MyFormatter1 < Log4r::Formatter
+  def format(event)
+    return "MyFormatter1\n"
+  end
+end
+
+class MyFormatter2 < Log4r::Formatter
+  def format(event)
+    return "MyFormatter2\n"
+  end
+end
+
+class TestLogger < TestCase
+  include Log4r
+
+  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_raise(ArgumentError) { Logger.new }
+    assert_nothing_raised { 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_raise(TypeError) { a.add 'bogus' }
+    assert_raise(TypeError) { a.add Class }
+    assert_raise(TypeError) { a.add 'fake1', Class }
+    assert_nothing_raised { a.add 'fake1', 'fake2' }
+  end
+  def test_repository
+    assert_raise(NameError) { Logger.get('bogusbogus') }
+    assert_nothing_raised { 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_raise(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_nothing_raised {
+      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,143 @@
+# encoding: utf-8
+require 'test_helper'
+
+class TestOutputter < TestCase
+  include Log4r
+
+  def test_validation
+    assert_raise(ArgumentError) { Outputter.new }
+    assert_raise(ArgumentError) { Outputter.new 'fonda', :level=>-10}
+    assert_raise(TypeError) { Outputter.new 'fonda', :formatter=>-10}
+  end
+  def test_io
+    assert_nothing_raised {
+      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'].class == IOOutputter )
+    assert( Outputter['foo4'].class == IOOutputter )
+    assert( Outputter['asdf'].class == IOOutputter )
+  end
+  def test_validation_and_creation
+    assert_nothing_raised {
+      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.class == DefaultFormatter)
+    b = StdoutOutputter.new('ook', :level => DEBUG, :formatter => Formatter)
+    assert(b.level == DEBUG)
+    assert(b.formatter.class == Formatter)
+    c = StdoutOutputter.new('akk', :formatter => Formatter)
+    assert(c.level == Logger.root.level)
+    assert(c.formatter.class == Formatter)
+    c = StderrOutputter.new('iikk', :level => OFF)
+    assert(c.level == OFF)
+    assert(c.formatter.class == DefaultFormatter)
+    o = StderrOutputter.new 'ik'
+    assert_nothing_raised(TypeError) { o.formatter = DefaultFormatter }
+    assert(o.formatter.class == DefaultFormatter)
+  end
+  # test the resource= bounds
+  def test_boundaries
+    o = StderrOutputter.new('ak', :formatter => Formatter)
+    assert_raise(TypeError) { o.formatter = nil }
+    assert_raise(TypeError) { o.formatter = String }
+    assert_raise(TypeError) { o.formatter = "bogus" }
+    assert_raise(TypeError) { o.formatter = -3 }
+    # the formatter should be preserved
+    assert(o.formatter.class == Formatter)
+  end
+  def test_file
+    assert_raise(TypeError) { FileOutputter.new 'f' }
+    assert_raise(TypeError) { FileOutputter.new('fa', :filename => DEBUG) }
+    assert_raise(TypeError) { FileOutputter.new('fo', :filename => nil) }
+    assert_nothing_raised {
+      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(o, mname.downcase.to_sym, "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_nothing_raised { o.debug event }
+    assert_nothing_raised { o.info event }
+    assert_raise(NameError) { o.warn event }
+    assert_raise(NameError) { o.error event }
+    assert_raise(NameError) { o.fatal event }
+    # now let's dynamically change the level and repeat
+    o.level = ERROR
+    assert_nothing_raised { o.debug event}
+    assert_nothing_raised { o.info event}
+    assert_nothing_raised { o.warn event}
+    assert_raise(NameError) { o.error event}
+    assert_raise(NameError) { o.fatal event}
+  end
+  def test_only_at_validation
+    o = StdoutOutputter.new 'so2'
+    assert_raise(ArgumentError) { o.only_at }
+    assert_raise(ArgumentError) { o.only_at ALL }
+    assert_raise(TypeError) { o.only_at OFF }
+    assert_nothing_raised { o.only_at DEBUG, ERROR }
+    return # cuz the rest is borked
+    # test the methods as before
+    event = LogEvent.new(nil,nil,nil,nil)
+    assert_raise(NameError) { o.debug event}
+    assert_raise(NameError) { o.error event}
+    assert_nothing_raised { o.warn event}
+    assert_nothing_raised { o.info event}
+    assert_nothing_raised { o.fatal event}
+  end
+  if defined?( Encoding )
+    # tests that files are opened in binary mode
+    def test_file_encoding
+      Encoding.default_internal = Encoding::UTF_8
+      File.open( './junk/tmp2', 'w' ) { |f| f.write( 'scheiß encoding' ) }
+      fenc = FileOutputter.new('fenc', :filename => './junk/tmp2')
+      event = LogEvent.new(1, Logger.root, nil, 'scheiß encoding'.force_encoding('ASCII-8BIT'))
+      assert_nothing_raised(Encoding::UndefinedConversionError) do
+        fenc.debug event
+      end
+    end
+  end
+  def broken_test_threading
+    class << self
+      def log_work
+	o = StdoutOutputter.new 'so2'
+	assert_nothing_raised { o.only_at DEBUG, ERROR }
+	Thread.current().exit()
+      end
+      def log_thread_start
+	t = Thread.new(log_work)
+	t.join
+      end
+    end
+
+    ts = Thread.new(log_thread_start)
+    ts.join
+  end
+end

data/tests/testpatternformatter.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class TestPatternFormatter < TestCase
+  include Log4r
+
+  def test_pattern
+    l = Logger.new 'test::this::that'
+    l.trace = true
+    o = StdoutOutputter.new 'test'
+    l.add o
+    assert_nothing_raised {
+    f = PatternFormatter.new :pattern=> "'%t' T-'%T' %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
+
+  def test_ndc
+    l = Logger.new 'test::this::that::other'
+    l.trace = true
+    o = StdoutOutputter.new 'testy'
+    l.add o
+    f = PatternFormatter.new :pattern=> "%d %6l [%C]%c {%x} %% %-40.30M"
+                             #:date_pattern=> "%Y"
+                             #:date_method => :usec
+    Outputter['testy'].formatter = f
+
+    l.info "no NDC"
+    NDC.push("start")
+    l.info "start NDC"
+    NDC.push("finish")
+    l.info "start finish NDC"
+    NDC.pop()
+    l.info "start NDC"
+    NDC.remove()
+    l.info "no NDC"
+  end
+
+  def test_gdc
+    l = Logger.new 'test::this::that::other'
+    l.trace = true
+    o = StdoutOutputter.new 'testy'
+    l.add o
+    f = PatternFormatter.new :pattern=> "%d %6l [%C]%c {%g} %% %-40.30M"
+                             #:date_pattern=> "%Y"
+                             #:date_method => :usec
+    Outputter['testy'].formatter = f
+
+    l.info "GDC default"
+    GDC.set("non-default")
+    l.info "GDC non-default"
+  end
+
+  def test_mdc
+    l = Logger.new 'test::this::that::other'
+    l.trace = true
+    o = StdoutOutputter.new 'testy'
+    l.add o
+    f = PatternFormatter.new :pattern=> "%d %6l [%C]%c {%X{user}} %% %-40.30M"
+                             #:date_pattern=> "%Y"
+                             #:date_method => :usec
+    Outputter['testy'].formatter = f
+
+    l.info "no user"
+    MDC.put("user","colbygk")
+    l.info "user colbygk"
+  end
+end

data/tests/testthreads.rb

@@ -0,0 +1,31 @@
+# $Id$
+# Test guts sent in by chetreddy bug #27184
+#
+# Note: this test won't always catch a threading problem, as it
+# relies on a brute force approach.  NUM_THREADS can be increased
+# to stress the system longer and therefore increasing the chance
+# of exposing a threading issue, however, it is not a definitive
+# test.
+#
+
+require 'test_helper'
+
+class TestThreads < TestCase
+  include Log4r
+
+  NUMTHREADS = 1000
+
+  def test_threads
+
+    assert_nothing_raised do
+      (0..NUMTHREADS).map do |i|
+        Thread.new do
+          Thread.current[:logger] = Log4r::Logger.new "Hello #{i}"
+          Thread.current[:logger].outputters = [StdoutOutputter.new("log4r#{i}")]
+          Thread.current[:logger].outputters.each { |j| j.flush }
+          Thread.current.exit()
+        end
+      end.each do |thr| thr.join end
+    end
+  end
+end

data/tests/testxmlconf.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+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
+  include Log4r
+
+  def test_load1
+    Configurator.load_xml_string(One)
+    assert_nothing_raised{ 
+      assert(Foo == 1) 
+      assert(Logger.global.level == ALL)
+    }
+  end
+  def test_load2
+    Configurator.load_xml_string(Two)
+    assert_nothing_raised{ 
+      assert(Logger.global.level == DEBUG)
+    }
+  end
+  def test_load3
+    Configurator.load_xml_string(Three)
+    assert_nothing_raised{ 
+      assert(Foo == 1) 
+      assert(Logger.global.level == Foo)
+    }
+  end
+  def test_load4
+    assert_nothing_raised {
+      Configurator['logpath'] = '.'
+      Configurator.load_xml_file "testconf.xml"
+      a = Logger['first::second']
+      a.bing "what the heck"
+    }
+  end
+end

data/tests/testyaml.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+
+# Define a custom outputter that allows arrays in configuration hash
+module Log4r
+  class TestYamlOutputter < Outputter
+    # expose array parameter
+    attr_reader :array_param
+
+    def initialize(name, hash = {})
+      @array_param = hash['array_param']
+    end
+  end
+end
+
+
+class TestYaml < TestCase
+  include Log4r
+
+  def setup
+    @cfg = YamlConfigurator # shorthand
+    @cfg['CUSTOM_DOMAIN'] = 'bar.com'
+  end
+
+  def test_injection
+    assert_nothing_raised("Exception injected") do
+      @cfg.load_yaml_file(File.join(File.dirname(__FILE__),'testyaml_injection.yaml'))
+    end
+  end
+
+  def test_arrays
+    assert_nothing_raised("Parser couldn't handle arrays in YAML") do
+      @cfg.load_yaml_file(File.join(File.dirname(__FILE__),'testyaml_arrays.yaml'))
+    end
+    log = Logger['mylogger']
+    assert_instance_of(Array, log.outputters.first.array_param, 'Array not loaded properly from YAML')
+    assert_equal('wilma@bar.com', log.outputters.first.array_param[2], '#{}-style parameter interpolation doesn\'t work properly in arrays')
+  end
+end
+

data/tests/testyaml_arrays.yaml

@@ -0,0 +1,25 @@
+log4r_config:
+
+  # define all loggers ...
+  loggers:
+    - name      : mylogger
+      level     : INFO
+      additive  : 'false'
+      trace     : 'false'      
+      outputters:
+        - testyaml
+
+  # define all outputters (incl. formatters)      
+  outputters:
+    - type     : TestYamlOutputter
+      name     : testyaml 
+      level    : INFO
+      array_param:
+        - fred@foo.com
+        - barney@foo.com
+        - 'wilma@#{CUSTOM_DOMAIN}'
+      formatter:
+        date_pattern: '%y%m%d %H:%M:%S'
+        pattern     : '%d %l: %m '
+        type        : PatternFormatter
+

data/tests/testyaml_injection.yaml

@@ -0,0 +1,22 @@
+log4r_config:
+
+  # define all loggers ...
+  loggers:
+    - name      : mylogger
+      level     : INFO
+      additive  : 'false'
+      trace     : 'false'      
+      outputters:
+        - stderr
+
+  # define all outputters (incl. formatters)      
+  outputters:
+    - type     : StderrOutputter
+      name     : stderr 
+      level    : INFO
+      crash    : "'; raise Exception #"
+      formatter:
+        date_pattern: '%y%m%d %H:%M:%S'
+        pattern     : '%d %l: %m '
+        type        : PatternFormatter
+