sgeorgi-logging 1.4.2

data/test/appenders/test_email.rb

@@ -0,0 +1,170 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+require 'flexmock'
+
+module TestLogging
+module TestAppenders
+
+  class TestEmail < Test::Unit::TestCase
+    include FlexMock::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      flexmock(Net::SMTP).new_instances do |m|
+        m.should_receive(:start).at_least.once.with(
+            'test.logging', 'test', 'test', :cram_md5, Proc).and_yield(m)
+        m.should_receive(:sendmail).at_least.once.with(String, 'me', ['you'])
+      end
+
+      @appender = Logging.appenders.email('email',
+          'from' => 'me', 'to' => 'you',
+          :buffer_size => '3', :immediate_at => 'error, fatal',
+          :domain => 'test.logging', :acct => 'test', :passwd => 'test'
+      )
+      @levels = Logging::LEVELS
+    end
+
+    def test_initialize
+      assert_raise(ArgumentError, 'Must specify from address') {
+        Logging.appenders.email('email')
+      }
+      assert_raise(ArgumentError, 'Must specify to address') {
+        Logging.appenders.email('email', :from => 'me')
+      }
+      assert_nothing_raised {
+        Logging.appenders.email('email', :from => 'me', :to => 'you')
+      }
+
+      appender = Logging.appenders.email('email',
+          'from' => 'me', 'to' => 'you'
+      )
+
+      assert_equal(100, appender.auto_flushing)
+      assert_equal([], appender.instance_variable_get(:@immediate))
+      assert_equal('localhost', appender.server)
+      assert_equal(25, appender.port)
+
+      domain = ENV['HOSTNAME'] || 'localhost.localdomain'
+      assert_equal(domain, appender.domain)
+      assert_equal(nil, appender.acct)
+      assert_equal(:cram_md5, appender.authtype)
+      assert_equal("Message of #{$0}", appender.subject)
+
+      appender = Logging.appenders.email('email',
+          'from' => 'lbrinn@gmail.com', 'to' => 'everyone',
+          :buffsize => '1000', :immediate_at => 'error, fatal',
+          :server => 'smtp.google.com', :port => '443',
+          :domain => 'google.com', :acct => 'lbrinn',
+          :passwd => '1234', :authtype => 'tls',
+          :subject => "I'm rich and you're not"
+      )
+
+      assert_equal('lbrinn@gmail.com', appender.instance_variable_get(:@from))
+      assert_equal(['everyone'], appender.instance_variable_get(:@to))
+      assert_equal(1000, appender.auto_flushing)
+      assert_equal('1234', appender.instance_variable_get(:@passwd))
+      assert_equal([nil, nil, nil, true, true],
+                   appender.instance_variable_get(:@immediate))
+      assert_equal('smtp.google.com', appender.server)
+      assert_equal(443, appender.port)
+      assert_equal('google.com', appender.domain)
+      assert_equal('lbrinn', appender.acct)
+      assert_equal(:tls, appender.authtype)
+      assert_equal("I'm rich and you're not", appender.subject)
+
+      appender = Logging.appenders.email('email',
+          'from' => 'me', 'to' => 'you', :auto_flushing => 42
+      )
+      assert_equal(42, appender.auto_flushing)
+    end
+
+    def test_append
+      # with auto_flushing enabled, mail will be sent each time a log event
+      # occurs
+      @appender.auto_flushing = true
+      event = Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # increase the buffer size and log a few events
+      @appender.auto_flushing = 3
+      @appender.append event
+      @appender.append event
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # error and fatal messages should be send immediately (no buffering)
+      error = Logging::LogEvent.new('ErrLogger', @levels['error'],
+                                    'error message', false)
+      fatal = Logging::LogEvent.new('FatalLogger', @levels['fatal'],
+                                    'fatal message', false)
+
+      @appender.append event
+      @appender.append fatal
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      @appender.append error
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      @appender.append event
+      assert_equal(1, @appender.buffer.length)
+    end
+
+    def test_concat
+      # with auto_flushing enabled, mail will be sent each time a log event
+      # occurs
+      @appender.auto_flushing = true
+      @appender << 'test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+
+      # increase the buffer size and log a few events
+      @appender.auto_flushing = 3
+      @appender << 'another test message'
+      @appender << 'a second test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender << 'a third test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+    end
+
+    def test_flush
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      @appender << 'test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.flush
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+    end
+
+    def test_close
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    [1, 2, 3, 4], false)
+      @appender.append event
+      @appender << 'test message'
+      assert_equal(2, @appender.buffer.length)
+
+      @appender.close
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.buffer.length)
+      assert(@appender.closed?)
+    end
+
+  end  # class TestEmail
+end  # module TestLogging
+end  # module TestAppenders
+
+# EOF

data/test/appenders/test_file.rb

@@ -0,0 +1,95 @@
+
+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/test/appenders/test_growl.rb

@@ -0,0 +1,127 @@
+
+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/test/appenders/test_io.rb

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