logging 0.9.4 → 0.9.5

data/tasks/spec.rake

@@ -0,0 +1,54 @@
+
+if HAVE_SPEC_RAKE_SPECTASK and not PROJ.spec.files.to_a.empty?
+require 'spec/rake/verify_rcov'
+
+namespace :spec do
+
+  desc 'Run all specs with basic output'
+  Spec::Rake::SpecTask.new(:run) do |t|
+    t.ruby_opts = PROJ.ruby_opts
+    t.spec_opts = PROJ.spec.opts
+    t.spec_files = PROJ.spec.files
+    t.libs += PROJ.libs
+  end
+
+  desc 'Run all specs with text output'
+  Spec::Rake::SpecTask.new(:specdoc) do |t|
+    t.ruby_opts = PROJ.ruby_opts
+    t.spec_opts = PROJ.spec.opts + ['--format', 'specdoc']
+    t.spec_files = PROJ.spec.files
+    t.libs += PROJ.libs
+  end
+
+  if HAVE_RCOV
+    desc 'Run all specs with RCov'
+    Spec::Rake::SpecTask.new(:rcov) do |t|
+      t.ruby_opts = PROJ.ruby_opts
+      t.spec_opts = PROJ.spec.opts
+      t.spec_files = PROJ.spec.files
+      t.libs += PROJ.libs
+      t.rcov = true
+      t.rcov_dir = PROJ.rcov.dir
+      t.rcov_opts = PROJ.rcov.opts + ['--exclude', 'spec']
+    end
+
+    RCov::VerifyTask.new(:verify) do |t| 
+      t.threshold = PROJ.rcov.threshold
+      t.index_html = File.join(PROJ.rcov.dir, 'index.html')
+      t.require_exact_threshold = PROJ.rcov.threshold_exact
+    end
+
+    task :verify => :rcov
+    remove_desc_for_task %w(spec:clobber_rcov)
+  end
+
+end  # namespace :spec
+
+desc 'Alias to spec:run'
+task :spec => 'spec:run'
+
+task :clobber => 'spec:clobber_rcov' if HAVE_RCOV
+
+end  # if HAVE_SPEC_RAKE_SPECTASK
+
+# EOF

data/tasks/svn.rake

@@ -0,0 +1,47 @@
+
+if HAVE_SVN
+
+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
+
+  # A prerequisites task that all other tasks depend upon
+  task :prereqs
+
+  desc 'Show tags from the SVN repository'
+  task :show_tags => 'svn:prereqs' 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 => 'svn:prereqs' 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

@@ -1,4 +1,5 @@
 
+if test(?e, PROJ.test.file) or not PROJ.test.files.to_a.empty?
 require 'rake/testtask'
 
 namespace :test do
@@ -34,4 +35,6 @@ task :test => 'test:run'
 
 task :clobber => 'test:clobber_rcov' if HAVE_RCOV
 
+end
+
 # EOF

data/test/appenders/test_buffered_io.rb

@@ -0,0 +1,183 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestAppenders
+
+  class TestBufferedIO < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+
+      @sio = StringIO.new
+      @appender = ::Logging::Appenders::IO.new(
+        'test_appender', @sio,
+        :auto_flushing => 3, :immediate_at => :error
+      )
+
+      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_raise(EOFError) {readline}
+
+      @appender.append event
+      assert_raise(EOFError) {readline}
+
+      event.level = @levels['debug']
+      event.data = 'the big log message'
+      @appender.append event
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      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_raise(EOFError) {log.readline}
+
+      @appender.append event
+      log.seek 0
+      assert_raise(EOFError) {log.readline}
+
+      @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_raise(EOFError) {readline}
+
+      @appender << "this is another message\n"
+      assert_raise(EOFError) {readline}
+
+      @appender << "some other line\n"
+
+      assert_equal "this is a test message\n", readline
+      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_raise(EOFError) {log.readline}
+
+      @appender << 'whoopsy'
+      log.seek 0
+      assert_raise(EOFError) {log.readline}
+
+      @appender << 'pooh'
+      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 << "this is a test message\n"
+      assert_raise(EOFError) {readline}
+
+      @appender.flush
+      assert_equal :flush, ary.pop
+      assert_equal "this is a test message\n", readline
+      assert_raise(EOFError) {readline}
+    end
+
+    def test_immediate_at
+      event = ::Logging::LogEvent.new('TestLogger', @levels['warn'],
+                                      [1, 2, 3, 4], false)
+      @appender.append event
+      assert_raise(EOFError) {readline}
+
+      event.level = @levels['error']
+      event.data = 'an error message'
+      @appender.append event
+
+      assert_equal " WARN  TestLogger : <Array> #{[1, 2, 3, 4]}\n", readline
+      assert_equal "ERROR  TestLogger : an error message\n", readline
+      assert_raise(EOFError) {readline}
+    end
+
+    private
+    def readline
+      @pos ||= 0
+      @sio.seek @pos
+      line = @sio.readline
+      @pos = @sio.tell
+      line
+    end
+
+  end  # class TestBufferedIO
+
+end  # module TestAppenders
+end  # module TestLogging
+
+# EOF

data/test/appenders/test_email.rb

@@ -22,7 +22,7 @@ module TestAppenders
 
       @appender = ::Logging::Appenders::Email.new('email',
           'from' => 'me', 'to' => 'you',
-          :buffsize => '3', :immediate_at => 'error, fatal',
+          :buffer_size => '3', :immediate_at => 'error, fatal',
           :domain => 'test.logging', :acct => 'test', :passwd => 'test'
       )
     end
@@ -42,7 +42,7 @@ module TestAppenders
           'from' => 'me', 'to' => 'you'
       )
 
-      assert_equal(100, appender.instance_variable_get(:@buffsize))
+      assert_equal(100, appender.auto_flushing)
       assert_equal([], appender.instance_variable_get(:@immediate))
       assert_equal('localhost', appender.server)
       assert_equal(25, appender.port)
@@ -64,7 +64,7 @@ module TestAppenders
 
       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(1000, appender.auto_flushing)
       assert_equal('1234', appender.instance_variable_get(:@passwd))
       assert_equal([nil, nil, nil, true, true],
                    appender.instance_variable_get(:@immediate))
@@ -74,27 +74,32 @@ module TestAppenders
       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.new('email',
+          'from' => 'me', 'to' => 'you', :auto_flushing => 42
+      )
+      assert_equal(42, appender.auto_flushing)
     end
 
     def test_append
-      # with a buffer size of 0, mail will be sent each time a log event
+      # with auto_flushing enabled, mail will be sent each time a log event
       # occurs
-      @appender.instance_variable_set(:@buffsize, 0)
+      @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.queued_messages)
+      assert_equal(0, @appender.buffer.length)
 
       # increase the buffer size and log a few events
-      @appender.instance_variable_set(:@buffsize, 3)
+      @appender.auto_flushing = 3
       @appender.append event
       @appender.append event
-      assert_equal(2, @appender.queued_messages)
+      assert_equal(2, @appender.buffer.length)
 
       @appender.append event
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
 
       # error and fatal messages should be send immediately (no buffering)
       error = ::Logging::LogEvent.new('ErrLogger', @levels['error'],
@@ -105,33 +110,33 @@ module TestAppenders
       @appender.append event
       @appender.append fatal
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
 
       @appender.append error
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
 
       @appender.append event
-      assert_equal(1, @appender.queued_messages)
+      assert_equal(1, @appender.buffer.length)
     end
 
     def test_concat
-      # with a buffer size of 0, mail will be sent each time a log event
+      # with auto_flushing enabled, mail will be sent each time a log event
       # occurs
-      @appender.instance_variable_set(:@buffsize, 0)
+      @appender.auto_flushing = true
       @appender << 'test message'
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
 
       # increase the buffer size and log a few events
-      @appender.instance_variable_set(:@buffsize, 3)
+      @appender.auto_flushing = 3
       @appender << 'another test message'
       @appender << 'a second test message'
-      assert_equal(2, @appender.queued_messages)
+      assert_equal(2, @appender.buffer.length)
 
       @appender << 'a third test message'
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
     end
 
     def test_flush
@@ -139,11 +144,11 @@ module TestAppenders
                                       [1, 2, 3, 4], false)
       @appender.append event
       @appender << 'test message'
-      assert_equal(2, @appender.queued_messages)
+      assert_equal(2, @appender.buffer.length)
 
       @appender.flush
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
     end
 
     def test_close
@@ -151,11 +156,11 @@ module TestAppenders
                                       [1, 2, 3, 4], false)
       @appender.append event
       @appender << 'test message'
-      assert_equal(2, @appender.queued_messages)
+      assert_equal(2, @appender.buffer.length)
 
       @appender.close
       assert_not_equal(@levels.length, @appender.level)
-      assert_equal(0, @appender.queued_messages)
+      assert_equal(0, @appender.buffer.length)
       assert(@appender.closed?)
     end
 

data/test/appenders/test_io.rb

@@ -51,6 +51,7 @@ module TestAppenders
       @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?
@@ -102,6 +103,7 @@ module TestAppenders
       @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