TwP-logging 0.9.7

data/test/appenders/test_file.rb

@@ -0,0 +1,93 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestFile < Test::Unit::TestCase
+    include LoggingTestCase
+
+    NAME = 'logfile'
+
+    def setup
+      super
+      ::Logging.init
+
+      FileUtils.mkdir [File.join(TMP, 'dir'), File.join(TMP, 'uw_dir')]
+      FileUtils.chmod 0555, File.join(TMP, 'uw_dir')
+      FileUtils.touch File.join(TMP, 'uw_file')
+      FileUtils.chmod 0444, File.join(TMP, 'uw_file')
+    end
+
+    def test_class_assert_valid_logfile
+      log = File.join(TMP, 'uw_dir', 'file.log')
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::File.assert_valid_logfile(log)
+      end
+
+      log = File.join(TMP, 'dir')
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::File.assert_valid_logfile(log)
+      end
+
+      log = File.join(TMP, 'uw_file')
+      assert_raise(ArgumentError) do
+        ::Logging::Appenders::File.assert_valid_logfile(log)
+      end
+
+      log = File.join(TMP, 'file.log')
+      assert ::Logging::Appenders::File.assert_valid_logfile(log)
+    end
+
+    def test_initialize
+      log = File.join(TMP, 'file.log')
+      appender = ::Logging::Appenders::File.new(NAME, 'filename' => log)
+      assert_equal 'logfile', appender.name
+      appender << "This will be the first line\n"
+      appender << "This will be the second line\n"
+      appender.flush
+      File.open(log, 'r') do |file|
+        assert_equal "This will be the first line\n", file.readline
+        assert_equal "This will be the second line\n", file.readline
+        assert_raise(EOFError) {file.readline}
+      end
+      cleanup
+
+      appender = ::Logging::Appenders::File.new NAME, :filename => log
+      assert_equal 'logfile', appender.name
+      appender << "This will be the third line\n"
+      appender.flush
+      File.open(log, 'r') do |file|
+        assert_equal "This will be the first line\n", file.readline
+        assert_equal "This will be the second line\n", file.readline
+        assert_equal "This will be the third line\n", file.readline
+        assert_raise(EOFError) {file.readline}
+      end
+      cleanup
+
+      appender = ::Logging::Appenders::File.new NAME, :filename => log,
+                                                      :truncate => true
+      assert_equal 'logfile', appender.name
+      appender << "The file was truncated\n"
+      appender.flush
+      File.open(log, 'r') do |file|
+        assert_equal "The file was truncated\n", file.readline
+        assert_raise(EOFError) {file.readline}
+      end
+      cleanup
+    end
+
+    private
+    def cleanup
+      unless ::Logging::Appender[NAME].nil?
+        ::Logging::Appender[NAME].close false
+        ::Logging::Appender[NAME] = nil
+      end
+    end
+
+  end  # class TestFile
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_growl.rb

@@ -0,0 +1,128 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+require 'flexmock'
+
+module TestLogging
+module TestAppenders
+
+  class TestGrowl < Test::Unit::TestCase
+    include FlexMock::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+
+      @appender = ::Logging::Appenders::Growl.new('growl',
+          :coalesce => true, :separator => "\000",
+          :layout => Logging::Layouts::Pattern.new(:pattern => "%5l - Test\000%m")
+      )
+      @appender.level = :all
+      @growl = @appender.instance_variable_get(:@growl).dup
+    end
+
+    def test_initialize
+      assert_equal('growlnotify -w -n "growl" -t "%s" -m "%s" -p %d &', @growl)
+      assert_equal(true, @appender.instance_variable_get(:@coalesce))
+      assert_equal("\000", @appender.instance_variable_get(:@title_sep))
+    end
+
+    def test_append
+      info = ::Logging::LogEvent.new('TestLogger', @levels['info'],
+                                     'info message', false)
+      warn = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                     'warning message', false)
+
+      flexmock(@appender).should_receive(:system => true).once.with(
+          @growl % ['WARN - Test', "warning message\nwarning message\nwarning message", 0])
+
+      flexmock(@appender).should_receive(:system => true).once.with(
+          @growl % ['INFO - Test', "info message\ninfo message", -1])
+
+      flexmock(@appender).should_receive(:system => true).once.with(
+          @growl % ['WARN - Test', "warning message", 0])
+
+      @appender.append warn
+      @appender.append warn
+      @appender.append warn
+      @appender.append info
+      @appender.append info
+      @appender.append warn
+      sleep 0.7  # give the coalescing thread time to run
+    end
+
+    def test_append_without_coalescing
+      @appender.instance_variable_set(:@coalesce, false)
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      'warning message', false)
+
+      flexmock(@appender).should_receive(:system => true).twice.with(
+          @growl % ['WARN - Test', 'warning message', 0])
+
+      @appender.append event
+      @appender.append event
+    end
+
+    def test_concat
+      flexmock(@appender).should_receive(:system => true).once.with(
+          @growl % ['', "first message\nsecond message\nthird message", 0])
+
+      @appender << 'first message'
+      @appender << 'second message'
+      @appender << 'third message'
+      sleep 0.7  # give the coalescing thread time to run
+    end
+
+    def test_concat_without_coalescing
+      @appender.instance_variable_set(:@coalesce, false)
+
+      flexmock(@appender).should_receive(:system => true).twice.with(
+          @growl % ['', 'concat message', 0])
+
+      @appender << 'concat message'
+      @appender << 'concat message'
+    end
+
+    def test_map_eq
+      get_map = lambda {@appender.instance_variable_get(:@map)}
+      assert_equal([-2,-1,0,1,2], get_map.call)
+
+      @appender.map = {
+        'fatal' => '0',
+        :error => -2,
+        :warn => '2',
+        'INFO' => 1,
+        'Debug' => -1
+      }
+      assert_equal([-1,1,2,-2,0], get_map.call)
+
+      assert_raise(ArgumentError) do
+        @appender.map = {:fatal => 'not a number', :error => 2}
+      end
+
+      assert_raise(ArgumentError) do
+        @appender.map = {:fatal => -3, :error => 3}
+      end
+    end
+
+    def test_disabling
+      @appender.instance_variable_set(:@coalesce, false)
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      'warning message', false)
+
+      flexmock(@appender).should_receive(:system => false).once.with(
+          @growl % ['WARN - Test', 'warning message', 0])
+
+      assert_equal 0, @appender.level
+      @appender.append event
+      assert_equal 5, @appender.level
+      @appender.append event
+      @appender.append event
+    end
+
+  end  # class TestGrowl
+end  # module TestLogging
+end  # module TestAppenders
+
+# EOF

data/test/appenders/test_io.rb

@@ -0,0 +1,142 @@
+
+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
+      # setup an internal logger to capture error messages from the IO
+      # appender
+      log = StringIO.new
+      Logging::Logger[Logging].add_appenders(
+        Logging::Appenders::IO.new('__internal_io', log)
+      )
+      Logging::Logger[Logging].level = 'all'
+
+
+      # close the string IO object so we get an error
+      @sio.close
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+
+      log.seek 0
+      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
+
+      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
+      # setup an internal logger to capture error messages from the IO
+      # appender
+      log = StringIO.new
+      Logging::Logger[Logging].add_appenders(
+        Logging::Appenders::IO.new('__internal_io', log)
+      )
+      Logging::Logger[Logging].level = 'all'
+
+      # close the string IO object so we get an error
+      @sio.close
+      @appender << 'oopsy'
+
+      log.seek 0
+      assert_equal "INFO  Logging : appender \"test_appender\" has been disabled", log.readline.strip
+      assert_equal "ERROR  Logging : <IOError> not opened for writing", log.readline.strip
+
+      # and the appender does not close itself
+      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,207 @@
+
+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
+
+    def test_file_removed
+      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)
+
+      # Now remove @fn and make sure that the log file is written to
+      # again
+      File.unlink(@fn)
+      assert_equal 0, Dir.glob(@glob).length
+
+      ap << 'X' * 50; ap.flush
+      assert_equal 1, Dir.glob(@glob).length
+      assert_equal 50, File.size(@fn)
+
+    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