redcar 0.3.1dev → 0.3.2dev

data/lib/logging/test/appenders/test_syslog.rb

@@ -1,194 +0,0 @@
-
-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

@@ -1,86 +0,0 @@
-
-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

@@ -1,70 +0,0 @@
-
-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

@@ -1,40 +0,0 @@
-
-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

@@ -1,42 +0,0 @@
-
-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

@@ -1,112 +0,0 @@
-
-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