redcar 0.2.9dev

data/lib/logging/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(
+        '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(:pattern => '%5l  %c : %m')
+      Logging.appenders.syslog(
+          'syslog_test',
+          :logopt => @logopt,
+          :facility => ::Syslog::LOG_USER,
+          :layout => layout
+      )
+    end
+
+    def get_map_from( syslog )
+      syslog.instance_variable_get :@map
+    end
+
+  end  # class TestSyslog
+
+end  # module TestAppenders
+end  # module TestLogging
+
+end  # HAVE_SYSLOG
+
+# EOF

data/lib/logging/test/benchmark.rb

@@ -0,0 +1,86 @@
+
+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 '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/lib/logging/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/lib/logging/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/lib/logging/test/layouts/test_basic.rb

@@ -0,0 +1,42 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestBasic < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.basic({})
+      @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/lib/logging/test/layouts/test_json.rb

@@ -0,0 +1,112 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestJson < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.json({})
+      @levels = Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+      Thread.current[:name] = nil
+    end
+
+    def test_initializer
+      assert_raise(ArgumentError) {
+        Logging.layouts.parseable.new :style => :foo
+      }
+    end
+
+    def test_format
+      fmt = %Q[\\{"timestamp":"#@date_fmt","level":"%s","logger":"%s","message":"%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_items
+      assert_equal %w[timestamp level logger message], @layout.items
+    end
+
+    def test_items_eq
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    ['log message'], false)
+
+      @layout.items = %w[timestamp]
+      assert_equal %w[timestamp], @layout.items
+      assert_match %r/\{"timestamp":"#@date_fmt"\}\n/, @layout.format(event)
+
+      # 'foo' is not a recognized item
+      assert_raise(ArgumentError) {
+        @layout.items = %w[timestamp logger foo]
+      }
+    end
+
+    def test_items_all
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    'log message', false)
+      event.file = 'test_file.rb'
+      event.line = 123
+      event.method = 'method_name'
+
+      @layout.items = %w[logger]
+      assert_equal %Q[{"logger":"TestLogger"}\n], @layout.format(event)
+
+      @layout.items = %w[file]
+      assert_equal %Q[{"file":"test_file.rb"}\n], @layout.format(event)
+
+      @layout.items = %w[level]
+      assert_equal %Q[{"level":"INFO"}\n], @layout.format(event)
+
+      @layout.items = %w[line]
+      assert_equal %Q[{"line":123}\n], @layout.format(event)
+
+      @layout.items = %w[message]
+      assert_equal %Q[{"message":"log message"}\n], @layout.format(event)
+
+      @layout.items = %w[method]
+      assert_equal %Q[{"method":"method_name"}\n], @layout.format(event)
+
+      @layout.items = %w[pid]
+      assert_match %r/\A\{"pid":\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[millis]
+      assert_match %r/\A\{"millis":\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread_id]
+      assert_match %r/\A\{"thread_id":-?\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread]
+      assert_equal %Q[{"thread":null}\n], @layout.format(event)
+      Thread.current[:name] = "Main"
+      assert_equal %Q[{"thread":"Main"}\n], @layout.format(event)
+    end
+
+  end  # class TestJson
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF