redcar 0.2.9dev

data/lib/logging/test/layouts/test_pattern.rb

@@ -0,0 +1,198 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestPattern < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.pattern({})
+      @levels = Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+      Thread.current[:name] = nil
+    end
+
+    def test_date_method
+      assert_nil @layout.date_method
+    end
+
+    def test_date_method_eq
+      @layout.date_method = :to_f
+      assert_equal :to_f, @layout.date_method
+      assert_instance_of Float, @layout.format_date(Time.now)
+
+      @layout.date_method = 'usec'
+      assert_equal 'usec', @layout.date_method
+      assert_instance_of Fixnum, @layout.format_date(Time.now)
+
+      @layout.date_method = :to_s
+      assert_equal :to_s, @layout.date_method
+      assert_instance_of String, @layout.format_date(Time.now)
+
+      # now, even if we have defined a date_pattern, the date_method should
+      # supersede the date_pattern
+      @layout.date_pattern = '%Y'
+
+      @layout.date_method = 'usec'
+      assert_equal 'usec', @layout.date_method
+      assert_instance_of Fixnum, @layout.format_date(Time.now)
+    end
+
+    def test_date_pattern
+      assert_equal '%Y-%m-%d %H:%M:%S', @layout.date_pattern
+    end
+
+    def test_date_pattern_eq
+      @layout.date_pattern = '%Y'
+      assert_equal '%Y', @layout.date_pattern
+      assert_match %r/\A\d{4}\z/, @layout.format_date(Time.now)
+
+      @layout.date_pattern = '%H:%M'
+      assert_equal '%H:%M', @layout.date_pattern
+      assert_match %r/\A\d{2}:\d{2}\z/, @layout.format_date(Time.now)
+    end
+
+    def test_format
+      fmt = '\[' + @date_fmt + '\] %s -- %s : %s\n'
+
+      event = Logging::LogEvent.new('ArrayLogger', @levels['info'],
+                                    'log message', false)
+      rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger', 'log message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.data = [1, 2, 3, 4]
+      rgxp  = Regexp.new(sprintf(fmt, 'INFO ', 'ArrayLogger',
+                                 Regexp.escape("<Array> #{[1,2,3,4]}")))
+      assert_match rgxp, @layout.format(event)
+
+      event.level = @levels['debug']
+      event.data = 'and another message'
+      rgxp  = Regexp.new(
+                  sprintf(fmt, 'DEBUG', 'ArrayLogger', 'and another message'))
+      assert_match rgxp, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = Exception.new
+      rgxp  = Regexp.new(
+                  sprintf(fmt, 'FATAL', 'Test', '<Exception> Exception'))
+      assert_match rgxp, @layout.format(event)
+    end
+
+    def test_format_date
+      rgxp = Regexp.new @date_fmt
+      assert_match rgxp, @layout.format_date(Time.now)
+    end
+
+    def test_pattern
+      assert_equal "[%d] %-5l -- %c : %m\n", @layout.pattern
+    end
+
+    def test_pattern_eq
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    ['log message'], false)
+
+      @layout.pattern = '%d'
+      assert_equal '%d', @layout.pattern
+      assert_match Regexp.new(@date_fmt), @layout.format(event)
+    end
+
+    def test_pattern_all
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    'log message', false)
+      event.file = 'test_file.rb'
+      event.line = '123'
+      event.method = 'method_name'
+
+      @layout.pattern = '%c'
+      assert_equal 'TestLogger', @layout.format(event)
+
+      @layout.pattern = '%d'
+      assert_match Regexp.new(@date_fmt), @layout.format(event)
+
+      @layout.pattern = '%F'
+      assert_equal 'test_file.rb', @layout.format(event)
+
+      @layout.pattern = '%l'
+      assert_equal 'INFO', @layout.format(event)
+
+      @layout.pattern = '%L'
+      assert_equal '123', @layout.format(event)
+
+      @layout.pattern = '%m'
+      assert_equal 'log message', @layout.format(event)
+
+      @layout.pattern = '%M'
+      assert_equal 'method_name', @layout.format(event)
+
+      @layout.pattern = '%p'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%r'
+      assert_match %r/\A\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%t'
+      assert_match %r/\A-?\d+\z/, @layout.format(event)
+
+      @layout.pattern = '%T'
+      assert_equal "", @layout.format(event)
+      Thread.current[:name] = "Main"
+      assert_equal "Main", @layout.format(event)
+
+      @layout.pattern = '%%'
+      assert_equal '%', @layout.format(event)
+
+      # 'z' is not a recognized format character
+      assert_raise(ArgumentError) {
+        @layout.pattern = '[%d] %% %c - %l %z blah'
+      }
+      assert_equal '%', @layout.format(event)
+
+      @layout.pattern = '%5l'
+      assert_equal ' INFO', @layout.format(event)
+
+      @layout.pattern = '%-5l'
+      assert_equal 'INFO ', @layout.format(event)
+
+      @layout.pattern = '%.1l, %c'
+      assert_equal 'I, TestLogger', @layout.format(event)
+
+      @layout.pattern = '%7.7m'
+      assert_equal 'log mes', @layout.format(event)
+
+      event.data = 'tim'
+      assert_equal '    tim', @layout.format(event)
+
+      @layout.pattern = '%-7.7m'
+      assert_equal 'tim    ', @layout.format(event)
+    end
+
+    def test_pattern_logger_name_precision
+      event = Logging::LogEvent.new('Foo', @levels['info'], 'message', false)
+
+      @layout.pattern = '%c{2}'
+      assert_equal 'Foo', @layout.format(event)
+
+      event.logger = 'Foo::Bar::Baz::Buz'
+      assert_equal 'Baz::Buz', @layout.format(event)
+
+      assert_raise(ArgumentError) {
+        @layout.pattern = '%c{0}'
+      }
+
+      @layout.pattern = '%c{foo}'
+      event.logger = 'Foo::Bar'
+      assert_equal 'Foo::Bar{foo}', @layout.format(event)
+
+      @layout.pattern = '%m{42}'
+      assert_equal 'message{42}', @layout.format(event)
+    end
+
+  end  # class TestBasic
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/layouts/test_yaml.rb

@@ -0,0 +1,121 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestYaml < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.yaml({})
+      @levels = Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+      Thread.current[:name] = nil
+    end
+
+    def test_format
+      h = {
+        'level' => 'INFO',
+        'logger' => 'ArrayLogger',
+        'message' => 'log message'
+      }
+
+      event = Logging::LogEvent.new('ArrayLogger', @levels['info'],
+                                    'log message', false)
+      assert_yaml_match h, @layout.format(event)
+
+      event.data = [1, 2, 3, 4]
+      h['message'] = "<Array> #{[1,2,3,4]}"
+      assert_yaml_match h, @layout.format(event)
+
+      event.level = @levels['debug']
+      event.data = 'and another message'
+      h['level'] = 'DEBUG'
+      h['message'] = 'and another message'
+      assert_yaml_match h, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = Exception.new
+      h['level'] = 'FATAL'
+      h['logger'] = 'Test'
+      h['message'] = '<Exception> Exception'
+      assert_yaml_match h, @layout.format(event)
+    end
+
+    def test_items
+      assert_equal %w[timestamp level logger message], @layout.items
+    end
+
+    def test_items_eq
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    ['log message'], false)
+
+      @layout.items = %w[timestamp]
+      assert_equal %w[timestamp], @layout.items
+      assert_match %r/--- \ntimestamp: #@date_fmt\n/, @layout.format(event)
+
+      # 'foo' is not a recognized item
+      assert_raise(ArgumentError) {
+        @layout.items = %w[timestamp logger foo]
+      }
+    end
+
+    def test_items_all
+      event = Logging::LogEvent.new('TestLogger', @levels['info'],
+                                    'log message', false)
+      event.file = 'test_file.rb'
+      event.line = 123
+      event.method = 'method_name'
+
+      @layout.items = %w[logger]
+      assert_equal %Q[--- \nlogger: TestLogger\n], @layout.format(event)
+
+      @layout.items = %w[file]
+      assert_equal %Q[--- \nfile: test_file.rb\n], @layout.format(event)
+
+      @layout.items = %w[level]
+      assert_equal %Q[--- \nlevel: INFO\n], @layout.format(event)
+
+      @layout.items = %w[line]
+      assert_equal %Q[--- \nline: 123\n], @layout.format(event)
+
+      @layout.items = %w[message]
+      assert_equal %Q[--- \nmessage: log message\n], @layout.format(event)
+
+      @layout.items = %w[method]
+      assert_equal %Q[--- \nmethod: method_name\n], @layout.format(event)
+
+      @layout.items = %w[pid]
+      assert_match %r/\A--- \npid: \d+\n\z/, @layout.format(event)
+
+      @layout.items = %w[millis]
+      assert_match %r/\A--- \nmillis: \d+\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread_id]
+      assert_match %r/\A--- \nthread_id: -?\d+\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread]
+      assert_equal %Q[--- \nthread: \n], @layout.format(event)
+      Thread.current[:name] = "Main"
+      assert_equal %Q[--- \nthread: Main\n], @layout.format(event)
+    end
+
+    private
+
+    def assert_yaml_match( expected, actual )
+      actual = YAML.load(actual)
+
+      assert_match %r/#@date_fmt/o, actual['timestamp']
+      assert_equal expected['level'], actual['level']
+      assert_equal expected['logger'], actual['logger']
+      assert_equal expected['message'], actual['message']
+    end
+
+  end  # class TestYaml
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/setup.rb

@@ -0,0 +1,44 @@
+
+# Equivalent to a header guard in C/C++
+# Used to prevent the class/module from being loaded more than once
+unless defined? LOGGING_TEST_SETUP
+LOGGING_TEST_SETUP = true
+
+require 'rubygems'
+require 'test/unit'
+require 'fileutils'
+begin
+  require 'turn'
+rescue LoadError; end
+
+# This line is needed for Ruby 1.9 -- hashes throw a "KeyError" in 1.9
+# whereas they throw an "IndexError" in 1.8
+#
+KeyError = IndexError if not defined? KeyError
+
+require File.join(File.dirname(__FILE__), %w[.. lib logging])
+
+
+module TestLogging
+module LoggingTestCase
+
+  TMP = 'tmp'
+
+  def setup
+    super
+    Logging.reset
+    FileUtils.rm_rf TMP
+    FileUtils.mkdir TMP
+  end
+    
+  def teardown
+    super
+    FileUtils.rm_rf TMP
+  end
+
+end  # module LoggingTestCase
+end  # module TestLogging
+
+end  # unless defined?
+
+# EOF

data/lib/logging/test/test_appender.rb

@@ -0,0 +1,152 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestAppender < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+
+      ::Logging.init
+      @levels = ::Logging::LEVELS
+      @event = ::Logging::LogEvent.new('logger', @levels['debug'],
+                                       'message', false)
+      @appender = ::Logging::Appender.new 'test_appender'
+    end
+
+    def test_append
+      ary = []
+      @appender.instance_variable_set :@ary, ary
+      def @appender.write( event )
+        str = event.instance_of?(::Logging::LogEvent) ?
+              @layout.format(event) : event.to_s
+        @ary << str
+      end
+
+      assert_nothing_raised {@appender.append @event}
+      assert_equal "DEBUG  logger : message\n", ary.pop
+
+      @appender.level = :info
+      @appender.append @event
+      assert_nil ary.pop
+
+      @event.level = @levels['info']
+      @appender.append @event
+      assert_equal " INFO  logger : message\n", ary.pop
+
+      @appender.close
+      assert_raise(RuntimeError) {@appender.append @event}
+    end
+
+    def test_close
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @appender.closed?
+    end
+
+    def test_closed_eh
+      assert_equal false, @appender.closed?
+
+      @appender.close
+      assert_equal true, @appender.closed?
+    end
+
+    def test_concat
+      ary = []
+      @appender.instance_variable_set :@ary, ary
+      def @appender.write( event )
+        str = event.instance_of?(::Logging::LogEvent) ?
+              @layout.format(event) : event.to_s
+        @ary << str
+      end
+
+      assert_nothing_raised {@appender << 'log message'}
+      assert_equal 'log message', ary.pop
+
+      @appender.level = :off
+      @appender << 'another log message'
+      assert_nil ary.pop
+
+      layout = @appender.layout
+      def layout.footer() 'this is the footer' end
+
+      @appender.close
+      assert_raise(RuntimeError)  {@appender << 'log message'}
+      assert_equal 'this is the footer', ary.pop
+    end
+
+    def test_flush
+      assert_same @appender, @appender.flush
+    end
+
+    def test_initialize
+      assert_raise(TypeError) {::Logging::Appender.new 'test', :layout => []}
+
+      layout = ::Logging::Layouts::Basic.new
+      @appender = ::Logging::Appender.new 'test', :layout => layout
+      assert_same layout, @appender.instance_variable_get(:@layout)
+    end
+
+    def test_layout
+      assert_instance_of ::Logging::Layouts::Basic, @appender.layout
+    end
+
+    def test_layout_eq
+      layout = ::Logging::Layouts::Basic.new
+      assert_not_equal layout, @appender.layout
+
+      assert_raise(TypeError) {@appender.layout = Object.new}
+      assert_raise(TypeError) {@appender.layout = 'not a layout'}
+
+      @appender.layout = layout
+      assert_same layout, @appender.layout
+    end
+
+    def test_level
+      assert_equal 0, @appender.level
+    end
+
+    def test_level_eq
+      assert_equal 0, @appender.level
+
+      assert_raise(ArgumentError) {@appender.level = -1}
+      assert_raise(ArgumentError) {@appender.level =  6}
+      assert_raise(ArgumentError) {@appender.level = Object}
+      assert_raise(ArgumentError) {@appender.level = 'bob'}
+      assert_raise(ArgumentError) {@appender.level = :wtf}
+
+      @appender.level = 'INFO'
+      assert_equal 1, @appender.level
+
+      @appender.level = :warn
+      assert_equal 2, @appender.level
+
+      @appender.level = 'error'
+      assert_equal 3, @appender.level
+
+      @appender.level = 4
+      assert_equal 4, @appender.level
+
+      @appender.level = 'off'
+      assert_equal 5, @appender.level
+
+      @appender.level = :all
+      assert_equal 0, @appender.level
+    end
+
+    def test_name
+      assert_equal 'test_appender', @appender.name
+    end
+
+    def test_inspect
+      expected = "<Appender:0x%x name=\"test_appender\">" % @appender.object_id
+      assert_equal expected, @appender.inspect
+    end
+
+  end  # class TestAppender
+end  # module TestLogging
+
+# EOF