TwP-logging 0.9.7

data/test/appenders/test_syslog.rb

@@ -0,0 +1,194 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+if HAVE_SYSLOG
+
+module TestLogging
+module TestAppenders
+
+  class TestSyslog < Test::Unit::TestCase
+    include LoggingTestCase
+    include ::Syslog::Constants
+
+    def setup
+      super
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+      @logopt = defined?(::Syslog::LOG_NDELAY) ?
+                    (::Syslog::LOG_PERROR | ::Syslog::LOG_NDELAY) :
+                    (::Syslog::LOG_PERROR)
+    end
+
+    def test_append
+      return if RUBY_PLATFORM =~ %r/cygwin/
+
+      stderr = IO::pipe
+
+      pid = fork do
+        stderr[0].close
+        STDERR.reopen(stderr[1])
+        stderr[1].close
+
+        appender = create_syslog
+        event = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                        [1, 2, 3, 4], false)
+        appender.append event
+        event.level = @levels['debug']
+        event.data = 'the big log message'
+        appender.append event
+
+        appender.level = :warn
+        event.level = @levels['info']
+        event.data = 'this message should not get logged'
+        appender.append event
+        event.level = @levels['warn']
+        event.data = 'this is your last warning'
+        appender.append event
+
+        exit!
+      end
+
+      stderr[1].close
+      Process.waitpid(pid)
+
+      assert_equal("syslog_test:  INFO  TestLogger : <Array> #{[1,2,3,4]}\n",
+                   stderr[0].gets)
+      assert_equal("syslog_test: DEBUG  TestLogger : the big log message\n",
+                   stderr[0].gets)
+      assert_equal("syslog_test:  WARN  TestLogger : this is your last warning\n",
+                   stderr[0].gets)
+    end
+
+    def test_append_error
+      appender = create_syslog
+      appender.close false
+
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      assert_raise(RuntimeError) {appender.append event}
+      assert_equal true, appender.closed?
+    end
+
+    def test_close
+      appender = create_syslog
+      assert_equal false, appender.closed?
+
+      appender.close false
+      assert_equal true, appender.closed?
+    end
+
+    def test_concat
+      return if RUBY_PLATFORM =~ %r/cygwin/
+
+      stderr = IO::pipe
+
+      pid = fork do
+        stderr[0].close
+        STDERR.reopen(stderr[1])
+        stderr[1].close
+
+        appender = create_syslog
+        appender << 'this is a test message'
+        appender << 'this is another message'
+        appender << 'some other line'
+
+        exit!
+      end
+
+      stderr[1].close
+      Process.waitpid(pid)
+
+      assert_equal("syslog_test: this is a test message\n", stderr[0].gets)
+      assert_equal("syslog_test: this is another message\n", stderr[0].gets)
+      assert_equal("syslog_test: some other line\n", stderr[0].gets)
+    end
+
+    def test_concat_error
+      appender = create_syslog
+      appender.close false
+
+      assert_raise(RuntimeError) {appender << 'oopsy'}
+      assert_equal true, appender.closed?
+    end
+
+    def test_map_eq
+      appender = create_syslog
+
+      assert_equal(
+        [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_CRIT],
+        get_map_from(appender)
+      )
+
+      appender.map = {
+        :debug => LOG_DEBUG,
+        :info  => 'LOG_NOTICE',
+        :warn  => :LOG_WARNING,
+        :error => 'log_err',
+        :fatal => :log_alert
+      }
+
+      assert_equal(
+        [LOG_DEBUG, LOG_NOTICE, LOG_WARNING, LOG_ERR, LOG_ALERT],
+        get_map_from(appender)
+      )
+    end
+
+    def test_map_eq_error
+      appender = create_syslog
+
+      # Object is not a valid syslog level
+      assert_raise(ArgumentError) do
+        appender.map = {:debug => Object}
+      end
+
+      # there is no syslog level named "info"
+      # it should be "log_info"
+      assert_raise(NameError) do
+        appender.map = {:info => 'lg_info'}
+      end
+    end
+
+    def test_initialize_map
+      appender = ::Logging::Appenders::Syslog.new(
+        'syslog_test',
+        :logopt => @logopt,
+        :map => {
+          :debug  =>  :log_debug,
+          :info   =>  :log_info,
+          :warn   =>  :log_warning,
+          :error  =>  :log_err,
+          :fatal  =>  :log_alert
+        }
+      )
+
+      assert_equal(
+        [LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERR, LOG_ALERT],
+        get_map_from(appender)
+      )
+    end
+
+
+    private
+
+    def create_syslog
+      layout = ::Logging::Layouts::Pattern.new(:pattern => '%5l  %c : %m')
+      ::Logging::Appenders::Syslog.new(
+          'syslog_test',
+          :logopt => @logopt,
+          :facility => ::Syslog::LOG_USER,
+          :layout => layout
+      )
+    end
+
+    def get_map_from( syslog )
+      syslog.instance_variable_get :@map
+    end
+
+  end  # class TestIO
+
+end  # module TestAppenders
+end  # module TestLogging
+
+end  # HAVE_SYSLOG
+
+# EOF

data/test/benchmark.rb

@@ -0,0 +1,87 @@
+
+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_configurator.rb

@@ -0,0 +1,70 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestConfig
+
+  class TestConfigurator < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_configuration
+      begin
+        load Logging.path(%w[data logging.rb])
+      rescue Exception => err
+        flunk err.inspect
+      end
+
+      levels = {
+        'deb' => 0,
+        'inf' => 1,
+        'prt' => 2,
+        'wrn' => 3,
+        'err' => 4,
+        'fat' => 5
+      }
+      assert_equal levels, Logging::LEVELS
+      assert_equal :inspect, Logging::OBJ_FORMAT
+
+      hash = Logging::Repository.instance.instance_variable_get(:@h)
+      assert hash.has_key?('A::B::C')
+      assert hash.has_key?('yourlogger')
+    end
+
+    def test_simple_configuration
+      begin
+        load Logging.path(%w[data simple_logging.rb])
+      rescue Exception => err
+        flunk err.inspect
+      end
+
+      levels = {
+        'debug' => 0,
+        'info'  => 1,
+        'warn'  => 2,
+        'error' => 3,
+        'fatal' => 4
+      }
+      assert_equal levels, Logging::LEVELS
+      assert_equal false, Logging.const_defined?('OBJ_FORMAT')
+
+      root = Logging::Logger.root
+      assert_equal 1, root.level
+    end
+
+    def test_bad_appender_configuration
+      assert_raise(Logging::Config::Configurator::Error) {
+        load Logging.path(%w[data bad_logging_1.rb])
+      }
+    end
+
+    def test_bad_layout_configuration
+      assert_raise(Logging::Config::Configurator::Error) {
+        load Logging.path(%w[data bad_logging_2.rb])
+      }
+    end
+  end
+
+end  # module TestConfig
+end  # module TestLogging
+
+# EOF

data/test/config/test_yaml_configurator.rb

@@ -0,0 +1,40 @@
+
+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,43 @@
+
+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,177 @@
+
+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 = '%T'
+      assert_equal "", @layout.format(event)
+      Thread.current[:name] = "Main"
+      assert_equal "Main", @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