filterfish-logging 0.9.8

data/test/appenders/test_io.rb

@@ -0,0 +1,113 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestIO < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+
+      @sio = StringIO.new
+      @appender = ::Logging::Appenders::IO.new 'test_appender', @sio
+      begin readline rescue EOFError end
+    end
+
+    def test_append
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_raise(EOFError) {readline}
+
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+      assert_equal "DEBUG  TestLogger : the big log message\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append event}
+    end
+
+    def test_append_error
+      @sio.close
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      assert_raise(IOError) {@appender.append event}
+      assert_equal false, @appender.closed?
+      assert_equal 5, @appender.level
+    end
+
+    def test_close
+      assert_equal false, @sio.closed?
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @sio.closed?
+      assert_equal true, @appender.closed?
+
+      [STDIN, STDERR, STDOUT].each do |io|
+        @appender = ::Logging::Appenders::IO.new 'test', io
+        @appender.close
+        assert_equal false, io.closed?
+        assert_equal true, @appender.closed?
+      end
+    end
+
+    def test_concat
+      @appender << "this is a test message\n"
+      assert_equal "this is a test message\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender << "this is another message\n"
+      @appender << "some other line\n"
+      assert_equal "this is another message\n", readline
+      assert_equal "some other line\n", readline
+      assert_raise(EOFError) {readline}
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender << 'message'}
+    end
+
+    def test_concat_error
+      @sio.close
+      assert_raise(IOError) {@appender << 'oopsy'}
+      assert_equal false, @appender.closed?
+      assert_equal 5, @appender.level
+    end
+
+    def test_flush
+      ary = []
+      @sio.instance_variable_set :@ary, ary
+      def @sio.flush() @ary << :flush end
+
+      @appender.flush
+      assert_equal :flush, ary.pop
+    end
+
+    def test_initialize
+      assert_raise(EOFError) {@sio.readline}
+      assert_raise(TypeError) {::Logging::Appenders::IO.new 'test', []}
+    end
+
+    private
+    def readline
+      @pos ||= 0
+      @sio.seek @pos
+      line = @sio.readline
+      @pos = @sio.tell
+      line
+    end
+
+  end  # class TestIO
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_rolling_file.rb

@@ -0,0 +1,187 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestRollingFile < Test::Unit::TestCase
+    include LoggingTestCase
+
+    NAME = 'roller'
+
+    def setup
+      super
+      ::Logging.init
+
+      @fn = File.join(TMP, 'test.log')
+      @fn_fmt = File.join(TMP, 'test.%d.log')
+      @glob = File.join(TMP, '*.log')
+    end
+
+    def test_initialize
+      assert_equal [], Dir.glob(@glob)
+
+      # create a new appender
+      ap = ::Logging::Appenders::RollingFile.new(NAME, :filename => @fn)
+      assert File.exist?(@fn)
+      assert_equal 0, File.size(@fn)
+
+      ap << "Just a line of text\n"   # 20 bytes
+      ap.flush
+      assert_equal 20, File.size(@fn)
+      cleanup
+
+      # make sure we append to the current file (not truncate)
+      ap = ::Logging::Appenders::RollingFile.new(NAME, :filename => @fn)
+      assert_equal [@fn], Dir.glob(@glob)
+      assert_equal 20, File.size(@fn)
+
+      ap << "Just another line of text\n"   # 26 bytes
+      ap.flush
+      assert_equal 46, File.size(@fn)
+      cleanup
+
+      # setting the truncate option to true should roll the current log file
+      # and create a new one
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, :truncate => true)
+
+      log1 = sprintf(@fn_fmt, 1)
+      assert_equal [log1, @fn], Dir.glob(@glob).sort
+      assert_equal 0, File.size(@fn)
+      assert_equal 46, File.size(log1)
+
+      ap << "Some more text in the new file\n"   # 31 bytes
+      ap.flush
+      assert_equal 31, File.size(@fn)
+      cleanup
+    end
+
+    def test_keep
+      assert_equal [], Dir.glob(@glob)
+
+      (1..12).each do |cnt|
+        name = sprintf(@fn_fmt, cnt)
+        File.open(name,'w') {|fd| fd.write 'X'*cnt}
+      end
+      FileUtils.touch(@fn)
+
+      # keep only five files
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, :keep => 5)
+
+      # we still have 13 files because we did not truncate the log file,
+      # and hence, we did not roll all the log files
+      assert_equal 13, Dir.glob(@glob).length
+
+      # force the appender to roll the files
+      ap.send :roll
+      assert_equal 6, Dir.glob(@glob).length
+
+      (1..5).each do |cnt|
+        name = sprintf(@fn_fmt, cnt)
+        assert_equal cnt-1, File.size(name)
+      end
+      cleanup
+    end
+
+    def test_age
+      assert_equal [], Dir.glob(@glob)
+
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::RollingFile.new(
+            NAME, :filename => @fn, :age => 'bob')
+      end
+
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, :age => 1)
+      ap << "random message\n"
+      assert_equal 1, Dir.glob(@glob).length
+
+      sleep 1.250
+      ap << "another random message\n"
+      assert_equal 2, Dir.glob(@glob).length
+
+      cleanup
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, 'age' => 'daily')
+      ap << "random message\n"
+      assert_equal 2, Dir.glob(@glob).length
+
+      age_fn = @fn + '.age'
+      now = ::File.mtime(age_fn)
+      start = now - 3600 * 24
+      ::File.utime(start, start, age_fn)
+
+      sleep 0.250
+      ap << "yet another random message\n"
+      assert_equal 3, Dir.glob(@glob).length
+
+      cleanup
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, :age => 'weekly')
+      ap << "random message\n"
+      assert_equal 3, Dir.glob(@glob).length
+
+      start = now - 3600 * 24 * 7
+      ::File.utime(start, start, age_fn)
+
+      sleep 0.250
+      ap << "yet another random message\n"
+      assert_equal 4, Dir.glob(@glob).length
+
+      cleanup
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, :age => 'monthly')
+      ap << "random message\n"
+      assert_equal 4, Dir.glob(@glob).length
+
+      start = now - 3600 * 24 * 31
+      ::File.utime(start, start, age_fn)
+
+      sleep 0.250
+      ap << "yet another random message\n"
+      assert_equal 5, Dir.glob(@glob).length
+    end
+
+    def test_size
+      assert_equal [], Dir.glob(@glob)
+
+      ap = ::Logging::Appenders::RollingFile.new(NAME,
+               :filename => @fn, :size => 100)
+
+      ap << 'X' * 100; ap.flush
+      assert_equal 1, Dir.glob(@glob).length
+      assert_equal 100, File.size(@fn)
+
+      # this character is appended to the log file (bringing its size to 101)
+      # and THEN the file is rolled resulting in a new, empty log file
+      ap << 'X'
+      assert_equal 2, Dir.glob(@glob).length
+      assert_equal 0, File.size(@fn)
+
+      ap << 'X' * 100; ap.flush
+      assert_equal 2, Dir.glob(@glob).length
+      assert_equal 100, File.size(@fn)
+
+      ap << 'X'
+      assert_equal 3, Dir.glob(@glob).length
+      assert_equal 0, File.size(@fn)
+
+      cleanup
+    end
+
+    private
+    def cleanup
+      unless ::Logging::Appender[NAME].nil?
+        ::Logging::Appender[NAME].close false
+        ::Logging::Appender[NAME] = nil
+      end
+    end
+
+  end  # class TestRollingFile
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_syslog.rb

@@ -0,0 +1,192 @@
+# $Id$
+
+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
+    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 => ::Syslog::LOG_PERROR | ::Syslog::LOG_NDELAY,
+        :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 => ::Syslog::LOG_PERROR | ::Syslog::LOG_NDELAY,
+          :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