filterfish-logging 0.9.8

data/test/benchmark.rb

@@ -0,0 +1,88 @@
+# $Id$
+
+begin
+  require 'logging'
+rescue LoadError
+  path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+  raise if $:.include? path
+  $: << path
+  retry
+end
+
+begin
+  require 'rubygems'
+  gem 'log4r'
+  require 'log4r'
+  $log4r = true
+rescue LoadError
+  $log4r = false
+end
+
+require 'benchmark'
+require 'stringio'
+require 'logger'
+
+module Logging
+  class Benchmark
+
+    def run
+      this_many = 300_000
+
+      sio = StringIO.new
+
+      logging = ::Logging.logger sio
+      logging.level = :warn
+
+      logger = ::Logger.new sio
+      logger.level = ::Logger::WARN
+
+      log4r = if $log4r
+        x = ::Log4r::Logger.new('benchmark')
+        x.level = ::Log4r::WARN
+        x.add ::Log4r::IOOutputter.new(
+          'benchmark', sio,
+          :formatter => ::Log4r::PatternFormatter.new(
+            :pattern => "%.1l, [%d #\#{Process.pid}] %5l : %M\n",
+            :date_pattern => "%Y-%m-%dT%H:%M:%S.\#{Time.now.usec}"
+          )
+        )
+        x
+      end
+
+      puts "== Debug (not logged) ==\n"
+      ::Benchmark.bm(10) do |bm|
+        bm.report('Logging:') {this_many.times {logging.debug 'not logged'}}
+        bm.report('Logger:') {this_many.times {logger.debug 'not logged'}}
+        bm.report('Log4r:') {this_many.times {log4r.debug 'not logged'}} if log4r
+      end
+
+      puts "\n== Warn (logged) ==\n"
+      ::Benchmark.bm(10) do |bm|
+        sio.seek 0
+        bm.report('Logging:') {this_many.times {logging.warn 'logged'}}
+        sio.seek 0
+        bm.report('Logger:') {this_many.times {logger.warn 'logged'}}
+        sio.seek 0
+        bm.report('Log4r:') {this_many.times {log4r.warn 'logged'}} if log4r
+      end
+
+      puts "\n== Concat ==\n"
+      ::Benchmark.bm(10) do |bm|
+        sio.seek 0
+        bm.report('Logging:') {this_many.times {logging << 'logged'}}
+        sio.seek 0
+        bm.report('Logger:') {this_many.times {logger << 'logged'}}
+        puts "Log4r:      not supported" if log4r
+      end
+    end
+
+  end  # class Benchmark
+end  # module Logging
+
+
+if __FILE__ == $0
+  bm = ::Logging::Benchmark.new
+  bm.run
+end
+
+# EOF

data/test/config/test_yaml_configurator.rb

@@ -0,0 +1,41 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestConfig
+
+  class TestYamlConfigurator < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_class_load
+      assert_raise(::Logging::Config::YamlConfigurator::Error) {
+        ::Logging::Config::YamlConfigurator.load(Object.new)
+      }
+
+      begin
+        fd = File.open('data/logging.yaml','r')
+        assert_nothing_raised {
+          ::Logging::Config::YamlConfigurator.load(fd)
+        }
+      ensure
+        fd.close
+      end
+    end
+
+    def test_initialize
+      io = StringIO.new
+      io << YAML.dump({:one => 1, :two => 2, :three => 3})
+      io.seek 0
+
+      assert_raise(::Logging::Config::YamlConfigurator::Error) {
+        ::Logging::Config::YamlConfigurator.new(io, :meh)
+      }
+    end
+
+  end  # class TestYamlConfigurator
+
+end  # module TestConfig
+end  # module TestLogging
+
+# EOF

data/test/layouts/test_basic.rb

@@ -0,0 +1,44 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestBasic < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @layout = ::Logging::Layouts::Basic.new
+      @levels = ::Logging::LEVELS
+    end
+
+    def test_format
+      event = ::Logging::LogEvent.new( 'ArrayLogger', @levels['info'],
+                                       'log message', false)
+      assert_equal " INFO  ArrayLogger : log message\n", @layout.format(event)
+
+      event.data = [1, 2, 3, 4]
+      assert_equal(" INFO  ArrayLogger : <Array> #{[1,2,3,4]}\n",
+                   @layout.format(event))
+
+      event.level = @levels['debug']
+      event.data = 'and another message'
+      log = "DEBUG  ArrayLogger : and another message\n"
+      assert_equal log, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = Exception.new
+      log = "FATAL  Test : <Exception> Exception\n"
+      assert_equal log, @layout.format(event)
+    end
+
+  end  # class TestBasic
+
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/test/layouts/test_pattern.rb

@@ -0,0 +1,173 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestPattern < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @layout = ::Logging::Layouts::Pattern.new
+      @levels = ::Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+    end
+
+    def test_date_method
+      assert_nil @layout.date_method
+    end
+
+    def test_date_method_eq
+      @layout.date_method = :to_f
+      assert_equal :to_f, @layout.date_method
+      assert_instance_of Float, @layout.format_date
+
+      @layout.date_method = 'usec'
+      assert_equal 'usec', @layout.date_method
+      assert_instance_of Fixnum, @layout.format_date
+
+      @layout.date_method = :to_s
+      assert_equal :to_s, @layout.date_method
+      assert_instance_of String, @layout.format_date
+
+      # now, even if we have defined a date_pattern, the date_method should
+      # supersede the date_pattern
+      @layout.date_pattern = '%Y'
+
+      @layout.date_method = 'usec'
+      assert_equal 'usec', @layout.date_method
+      assert_instance_of Fixnum, @layout.format_date
+    end
+
+    def test_date_pattern
+      assert_equal '%Y-%m-%d %H:%M:%S', @layout.date_pattern
+    end
+
+    def test_date_pattern_eq
+      @layout.date_pattern = '%Y'
+      assert_equal '%Y', @layout.date_pattern
+      assert_match %r/\A\d{4}\z/, @layout.format_date
+
+      @layout.date_pattern = '%H:%M'
+      assert_equal '%H:%M', @layout.date_pattern
+      assert_match %r/\A\d{2}:\d{2}\z/, @layout.format_date
+    end
+
+    def test_format
+      fmt = '\[' + @date_fmt + '\] %s -- %s : %s\n'
+
+      event = ::Logging::LogEvent.new('ArrayLogger', @levels['info'],
+                                      'log message', false)
+      rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger', 'log message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.data = [1, 2, 3, 4]
+      rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger',
+                                 Regexp.escape("<Array> #{[1,2,3,4]}")))
+      assert_match rgxp, @layout.format(event)
+
+      event.level = @levels['debug']
+      event.data = 'and another message'
+      rgxp  = Regexp.new(
+                  sprintf(fmt, 'DEBUG', 'ArrayLogger', 'and another message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = Exception.new
+      rgxp  = Regexp.new(
+                  sprintf(fmt, 'FATAL', 'Test', '<Exception> Exception'))
+      assert_match rgxp, @layout.format(event)
+    end
+
+    def test_format_date
+      rgxp = Regexp.new @date_fmt
+      assert_match rgxp, @layout.format_date
+    end
+
+    def test_pattern
+      assert_equal "[%d] %-5l -- %c : %m\n", @layout.pattern
+    end
+
+    def test_pattern_eq
+      event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      ['log message'], false)
+
+      @layout.pattern = '%d'
+      assert_equal '%d', @layout.pattern
+      assert_match Regexp.new(@date_fmt), @layout.format(event)
+    end
+
+    def test_pattern_all
+      event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                      'log message', false)
+      event.instance_variable_set :@file, 'test_file.rb'
+      event.instance_variable_set :@line, '123'
+      event.instance_variable_set :@method, 'method_name'
+
+      @layout.pattern = '%c'
+      assert_equal 'TestLogger', @layout.format(event)
+
+      @layout.pattern = '%d'
+      assert_match Regexp.new(@date_fmt), @layout.format(event)
+
+      @layout.pattern = '%F'
+      assert_equal 'test_file.rb', @layout.format(event)
+
+      @layout.pattern = '%l'
+      assert_equal 'INFO', @layout.format(event)
+
+      @layout.pattern = '%L'
+      assert_equal '123', @layout.format(event)
+
+      @layout.pattern = '%m'
+      assert_equal 'log message', @layout.format(event)
+
+      @layout.pattern = '%M'
+      assert_equal 'method_name', @layout.format(event)
+
+      @layout.pattern = '%p'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%r'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%t'
+      assert_match %r/\A-?\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%%'
+      assert_equal '%', @layout.format(event)
+
+      # 'z' is not a recognized format character
+      assert_raise(ArgumentError) {
+        @layout.pattern = '[%d] %% %c - %l %z blah'
+      }
+      assert_equal '%', @layout.format(event)
+
+      @layout.pattern = '%5l'
+      assert_equal ' INFO', @layout.format(event)
+
+      @layout.pattern = '%-5l'
+      assert_equal 'INFO ', @layout.format(event)
+
+      @layout.pattern = '%.1l, %c'
+      assert_equal 'I, TestLogger', @layout.format(event)
+
+      @layout.pattern = '%7.7m'
+      assert_equal 'log mes', @layout.format(event)
+
+      event.data = 'tim'
+      assert_equal '    tim', @layout.format(event)
+
+      @layout.pattern = '%-7.7m'
+      assert_equal 'tim    ', @layout.format(event)
+    end
+
+  end  # class TestBasic
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/test/setup.rb

@@ -0,0 +1,66 @@
+# $Id$
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? LOGGING_TEST_SETUP
+LOGGING_TEST_SETUP = true
+
+require 'rubygems'
+require 'test/unit'
+require 'fileutils'
+require 'stringio'
+require 'turn' rescue nil
+
+# This line is needed for Ruby 1.9 -- hashes throw a "KeyError" in 1.9
+# whereas they throw an "IndexError" in 1.8
+#
+KeyError = IndexError if not defined? KeyError
+
+require File.join(File.dirname(__FILE__), %w[.. lib logging])
+
+
+module TestLogging
+module LoggingTestCase
+
+  TMP = 'tmp'
+
+  def setup
+    super
+
+    FileUtils.rm_rf TMP
+    FileUtils.mkdir TMP
+
+    ::Logging.module_eval do
+      ::Logging::LEVELS.clear
+      ::Logging::LNAMES.clear
+      remove_const :MAX_LEVEL_LENGTH if const_defined? :MAX_LEVEL_LENGTH
+      remove_const :OBJ_FORMAT if const_defined? :OBJ_FORMAT
+    end
+
+    ::Logging::Repository.class_eval do
+      if defined?(@singleton__instance__)
+        @singleton__instance__ = nil
+      else
+        @__instance__ = nil
+        class << self
+          nonce = class << Singleton; self; end
+          define_method(:instance, nonce::FirstInstanceCall)
+        end
+      end
+    end
+  end
+    
+  def teardown
+    super
+    h = ::Logging::Appender.instance_variable_get(:@appenders)
+    h.each_value {|a| a.close(false) unless a.nil? || a.closed?}
+    h.clear
+    FileUtils.rm_rf TMP
+  end
+
+end  # module LoggingTestCase
+end  # module TestLogging
+
+end  # unless defined?
+
+# EOF

data/test/test_appender.rb

@@ -0,0 +1,162 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestAppender < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+      @event = ::Logging::LogEvent.new('logger', @levels['debug'],
+                                       'message', false)
+      @appender = ::Logging::Appender.new 'test_appender'
+    end
+
+    def test_append
+      ary = []
+      @appender.instance_variable_set :@ary, ary
+      def @appender.write( event )
+        str = event.instance_of?(::Logging::LogEvent) ?
+              @layout.format(event) : event.to_s
+        @ary << str
+      end
+
+      assert_nothing_raised {@appender.append @event}
+      assert_equal "DEBUG  logger : message\n", ary.pop
+
+      @appender.level = :info
+      @appender.append @event
+      assert_nil ary.pop
+
+      @event.level = @levels['info']
+      @appender.append @event
+      assert_equal " INFO  logger : message\n", ary.pop
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append @event}
+    end
+
+    def test_class_stderr
+      stderr = ::Logging::Appender.stderr
+      assert_instance_of ::Logging::Appenders::Stderr, stderr
+      assert_equal 'stderr', stderr.name
+      assert_same stderr, ::Logging::Appender.stderr
+    end
+
+    def test_class_stdout
+      stdout = ::Logging::Appender.stdout
+      assert_instance_of ::Logging::Appenders::Stdout, stdout
+      assert_equal 'stdout', stdout.name
+      assert_same stdout, ::Logging::Appender.stdout
+    end
+
+    def test_close
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @appender.closed?
+    end
+
+    def test_closed_eh
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @appender.closed?
+    end
+
+    def test_concat
+      ary = []
+      @appender.instance_variable_set :@ary, ary
+      def @appender.write( event )
+        str = event.instance_of?(::Logging::LogEvent) ?
+              @layout.format(event) : event.to_s
+        @ary << str
+      end
+
+      assert_nothing_raised {@appender << 'log message'}
+      assert_equal 'log message', ary.pop
+
+      @appender.level = :off
+      @appender << 'another log message'
+      assert_nil ary.pop
+
+      layout = @appender.layout
+      def layout.footer() 'this is the footer' end
+
+      @appender.close
+      assert_raise(RuntimeError)  {@appender << 'log message'}
+      assert_equal 'this is the footer', ary.pop
+    end
+
+    def test_flush
+      assert_same @appender, @appender.flush
+    end
+
+    def test_initialize
+      assert_raise(TypeError) {::Logging::Appender.new 'test', :layout => []}
+
+      layout = ::Logging::Layouts::Basic.new
+      @appender = ::Logging::Appender.new 'test', :layout => layout
+      assert_same layout, @appender.instance_variable_get(:@layout)
+    end
+
+    def test_layout
+      assert_instance_of ::Logging::Layouts::Basic, @appender.layout
+    end
+
+    def test_layout_eq
+      layout = ::Logging::Layouts::Basic.new
+      assert_not_equal layout, @appender.layout
+
+      assert_raise(TypeError) {@appender.layout = Object.new}
+      assert_raise(TypeError) {@appender.layout = 'not a layout'}
+
+      @appender.layout = layout
+      assert_same layout, @appender.layout
+    end
+
+    def test_level
+      assert_equal 0, @appender.level
+    end
+
+    def test_level_eq
+      assert_equal 0, @appender.level
+
+      assert_raise(ArgumentError) {@appender.level = -1}
+      assert_raise(ArgumentError) {@appender.level =  6}
+      assert_raise(ArgumentError) {@appender.level = Object}
+      assert_raise(ArgumentError) {@appender.level = 'bob'}
+      assert_raise(ArgumentError) {@appender.level = :wtf}
+
+      @appender.level = 'INFO'
+      assert_equal 1, @appender.level
+
+      @appender.level = :warn
+      assert_equal 2, @appender.level
+
+      @appender.level = 'error'
+      assert_equal 3, @appender.level
+
+      @appender.level = 4
+      assert_equal 4, @appender.level
+
+      @appender.level = 'off'
+      assert_equal 5, @appender.level
+
+      @appender.level = :all
+      assert_equal 0, @appender.level
+    end
+
+    def test_name
+      assert_equal 'test_appender', @appender.name
+    end
+
+  end  # class TestAppender
+end  # module TestLogging
+
+# EOF