redcar 0.3.1dev → 0.3.2dev

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

@@ -1,95 +0,0 @@
-
-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(NAME, 'filename' => log)
-      assert_equal 'logfile', appender.name
-      assert_equal log, appender.filename
-      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(NAME, :filename => log)
-      assert_equal 'logfile', appender.name
-      assert_equal log, appender.filename
-      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(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.appenders[NAME].nil?
-        Logging.appenders[NAME].close false
-        Logging.appenders[NAME] = nil
-      end
-    end
-
-  end  # class TestFile
-
-end  # module TestAppenders
-end  # module TestLogging
-
-# EOF

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

@@ -1,127 +0,0 @@
-
-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
-
-      @appender = Logging.appenders.growl('growl',
-          :coalesce => true, :separator => "\000",
-          :layout => Logging.layouts.pattern(:pattern => "%5l - Test\000%m")
-      )
-      @appender.level = :all
-      @growl = @appender.instance_variable_get(:@growl).dup
-      @levels = Logging::LEVELS
-    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/lib/logging/test/appenders/test_io.rb

@@ -1,129 +0,0 @@
-
-require File.join(File.dirname(__FILE__), %w[.. setup])
-
-module TestLogging
-module TestAppenders
-
-  class TestIO < Test::Unit::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-
-      @appender = Logging.appenders.string_io('test_appender')
-      @sio = @appender.sio
-      @levels = Logging::LEVELS
-    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_nil(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_nil(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 = Logging.appenders.string_io('__internal_io')
-      Logging.logger[Logging].add_appenders(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
-
-      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('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_nil(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_nil(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 = Logging.appenders.string_io('__internal_io')
-      Logging.logger[Logging].add_appenders(log)
-      Logging.logger[Logging].level = 'all'
-
-      # close the string IO object so we get an error
-      @sio.close
-      @appender << 'oopsy'
-
-      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('test', [])}
-    end
-
-    private
-    def readline
-      @appender.readline
-    end
-
-  end  # class TestIO
-
-end  # module TestAppenders
-end  # module TestLogging
-
-# EOF

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

@@ -1,200 +0,0 @@
-
-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.rolling_file(NAME, :filename => @fn)
-      assert_equal @fn, ap.filename
-      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.rolling_file(NAME, :filename => @fn)
-      assert_equal @fn, ap.filename
-      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.rolling_file(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.rolling_file(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.rolling_file(NAME, :filename => @fn, :age => 'bob')
-      end
-
-      ap = Logging.appenders.rolling_file(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.rolling_file(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.rolling_file(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.rolling_file(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.rolling_file(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.rolling_file(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.appenders[NAME].nil?
-        Logging.appenders[NAME].close false
-        Logging.appenders[NAME] = nil
-      end
-    end
-
-  end  # class TestRollingFile
-end  # module TestAppenders
-end  # module TestLogging
-
-# EOF