filterfish-logging 0.9.8

data/tasks/svn.rake

@@ -0,0 +1,45 @@
+# $Id$
+
+if PROJ.svn.path and system("svn --version 2>&1 > #{DEV_NULL}")
+
+unless PROJ.svn.root
+  info = %x/svn info ./
+  m = %r/^Repository Root:\s+(.*)$/.match(info)
+  PROJ.svn.root = (m.nil? ? '' : m[1])
+end
+PROJ.svn.root = File.join(PROJ.svn.root, PROJ.svn.path) unless PROJ.svn.path.empty?
+
+namespace :svn do
+
+  desc 'Show tags from the SVN repository'
+  task :show_tags do |t|
+    tags = %x/svn list #{File.join(PROJ.svn.root, PROJ.svn.tags)}/
+    tags.gsub!(%r/\/$/, '')
+    tags = tags.split("\n").sort {|a,b| b <=> a}
+    puts tags
+  end
+
+  desc 'Create a new tag in the SVN repository'
+  task :create_tag do |t|
+    v = ENV['VERSION'] or abort 'Must supply VERSION=x.y.z'
+    abort "Versions don't match #{v} vs #{PROJ.version}" if v != PROJ.version
+
+    svn = PROJ.svn
+    trunk = File.join(svn.root, svn.trunk)
+    tag = "%s-%s" % [PROJ.name, PROJ.version]
+    tag = File.join(svn.root, svn.tags, tag)
+    msg = "Creating tag for #{PROJ.name} version #{PROJ.version}"
+
+    puts "Creating SVN tag '#{tag}'"
+    unless system "svn cp -m '#{msg}' #{trunk} #{tag}"
+      abort "Tag creation failed" 
+    end
+  end
+
+end  # namespace :svn
+
+task 'gem:release' => 'svn:create_tag'
+
+end  # if PROJ.svn.path
+
+# EOF

data/tasks/test.rake

@@ -0,0 +1,38 @@
+# $Id$
+
+require 'rake/testtask'
+
+namespace :test do
+
+  Rake::TestTask.new(:run) do |t|
+    t.libs = PROJ.libs
+    t.test_files = if test(?f, PROJ.test.file) then [PROJ.test.file]
+                   else PROJ.test.files end
+    t.ruby_opts += PROJ.ruby_opts
+    t.ruby_opts += PROJ.test.opts
+  end
+
+  if HAVE_RCOV
+    desc 'Run rcov on the unit tests'
+    task :rcov => :clobber_rcov do
+      opts = PROJ.rcov.opts.dup << '-o' << PROJ.rcov.dir
+      opts = opts.join(' ')
+      files = if test(?f, PROJ.test.file) then [PROJ.test.file]
+              else PROJ.test.files end
+      files = files.join(' ')
+      sh "#{RCOV} #{files} #{opts}"
+    end
+
+    task :clobber_rcov do
+      rm_r 'coverage' rescue nil
+    end
+  end
+
+end  # namespace :test
+
+desc 'Alias to test:run'
+task :test => 'test:run'
+
+task :clobber => 'test:clobber_rcov' if HAVE_RCOV
+
+# EOF

data/test/appenders/test_console.rb

@@ -0,0 +1,40 @@
+# $Id$
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestStdout < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_initialize
+      appender = ::Logging::Appenders::Stdout.new
+      assert_equal 'stdout', appender.name
+      assert_same STDOUT, appender.instance_variable_get(:@io)
+
+      appender.close
+      assert_equal true, appender.closed?
+      assert_equal false, STDOUT.closed?
+    end
+
+  end  # class TestStdout
+
+  class TestStderr < Test::Unit::TestCase
+
+    def test_initialize
+      appender = ::Logging::Appenders::Stderr.new
+      assert_equal 'stderr', appender.name
+      assert_same STDERR, appender.instance_variable_get(:@io)
+
+      appender.close
+      assert_equal true, appender.closed?
+      assert_equal false, STDERR.closed?
+    end
+
+  end  # class TestStderr
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_email.rb

@@ -0,0 +1,167 @@
+# $Id$
+
+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
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+
+      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.new('email',
+          'from' => 'me', 'to' => 'you',
+          :buffsize => '3', :immediate_at => 'error, fatal',
+          :domain => 'test.logging', :acct => 'test', :passwd => 'test'
+      )
+    end
+
+    def test_initialize
+      assert_raise(ArgumentError, 'Must specify from address') {
+        ::Logging::Appenders::Email.new('email')
+      }
+      assert_raise(ArgumentError, 'Must specify to address') {
+        ::Logging::Appenders::Email.new('email', :from => 'me')
+      }
+      assert_nothing_raised {
+        ::Logging::Appenders::Email.new('email', :from => 'me', :to => 'you')
+      }
+
+      appender = ::Logging::Appenders::Email.new('email',
+          'from' => 'me', 'to' => 'you'
+      )
+
+      assert_equal(100, appender.instance_variable_get(:@buffsize))
+      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.new('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.instance_variable_get(:@buffsize))
+      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)
+    end
+
+    def test_append
+      # with a buffer size of 0, mail will be sent each time a log event
+      # occurs
+      @appender.instance_variable_set(:@buffsize, 0)
+      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.queued_messages)
+
+      # increase the buffer size and log a few events
+      @appender.instance_variable_set(:@buffsize, 3)
+      @appender.append event
+      @appender.append event
+      assert_equal(2, @appender.queued_messages)
+
+      @appender.append event
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.queued_messages)
+
+      # 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.queued_messages)
+
+      @appender.append error
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.queued_messages)
+
+      @appender.append event
+      assert_equal(1, @appender.queued_messages)
+    end
+
+    def test_concat
+      # with a buffer size of 0, mail will be sent each time a log event
+      # occurs
+      @appender.instance_variable_set(:@buffsize, 0)
+      @appender << 'test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.queued_messages)
+
+      # increase the buffer size and log a few events
+      @appender.instance_variable_set(:@buffsize, 3)
+      @appender << 'another test message'
+      @appender << 'a second test message'
+      assert_equal(2, @appender.queued_messages)
+
+      @appender << 'a third test message'
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.queued_messages)
+    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.queued_messages)
+
+      @appender.flush
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.queued_messages)
+    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.queued_messages)
+
+      @appender.close
+      assert_not_equal(@levels.length, @appender.level)
+      assert_equal(0, @appender.queued_messages)
+      assert(@appender.closed?)
+    end
+
+  end  # class TestEmail
+end  # module TestLogging
+end  # module TestAppenders
+
+# EOF

data/test/appenders/test_file.rb

@@ -0,0 +1,94 @@
+# $Id$
+
+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,115 @@
+# $Id$
+
+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 &', 
+                   @appender.instance_variable_get(:@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).once.with(
+          @growl % ['WARN - Test', "warning message\nwarning message\nwarning message", 0])
+
+      flexmock(@appender).should_receive(:system).once.with(
+          @growl % ['INFO - Test', "info message\ninfo message", -1])
+
+      flexmock(@appender).should_receive(:system).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).twice.with(
+          @growl % ['WARN - Test', 'warning message', 0])
+
+      @appender.append event
+      @appender.append event
+    end
+
+    def test_concat
+      flexmock(@appender).should_receive(:system).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).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
+
+  end  # class TestGrowl
+end  # module TestLogging
+end  # module TestAppenders
+
+# EOF