sgeorgi-logging 1.4.2

data/test/config/test_configurator.rb

@@ -0,0 +1,70 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestConfig
+
+  class TestConfigurator < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_configuration
+      begin
+        load Logging.path(%w[data logging.rb])
+      rescue Exception => err
+        flunk err.inspect
+      end
+
+      levels = {
+        'deb' => 0,
+        'inf' => 1,
+        'prt' => 2,
+        'wrn' => 3,
+        'err' => 4,
+        'fat' => 5
+      }
+      assert_equal levels, Logging::LEVELS
+      assert_equal :inspect, Logging::OBJ_FORMAT
+
+      hash = Logging::Repository.instance.instance_variable_get(:@h)
+      assert hash.has_key?('A::B::C')
+      assert hash.has_key?('yourlogger')
+    end
+
+    def test_simple_configuration
+      begin
+        load Logging.path(%w[data simple_logging.rb])
+      rescue Exception => err
+        flunk err.inspect
+      end
+
+      levels = {
+        'debug' => 0,
+        'info'  => 1,
+        'warn'  => 2,
+        'error' => 3,
+        'fatal' => 4
+      }
+      assert_equal levels, Logging::LEVELS
+      assert_equal false, Logging.const_defined?('OBJ_FORMAT')
+
+      root = Logging::Logger.root
+      assert_equal 1, root.level
+    end
+
+    def test_bad_appender_configuration
+      assert_raise(Logging::Config::Configurator::Error) {
+        load Logging.path(%w[data bad_logging_1.rb])
+      }
+    end
+
+    def test_bad_layout_configuration
+      assert_raise(Logging::Config::Configurator::Error) {
+        load Logging.path(%w[data bad_logging_2.rb])
+      }
+    end
+  end
+
+end  # module TestConfig
+end  # module TestLogging
+
+# EOF

data/test/config/test_yaml_configurator.rb

@@ -0,0 +1,40 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestConfig
+
+  class TestYamlConfigurator < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_class_load
+      assert_raise(::Logging::Config::YamlConfigurator::Error) {
+        ::Logging::Config::YamlConfigurator.load(Object.new)
+      }
+
+      begin
+        fd = File.open('data/logging.yaml','r')
+        assert_nothing_raised {
+          ::Logging::Config::YamlConfigurator.load(fd)
+        }
+      ensure
+        fd.close
+      end
+    end
+
+    def test_initialize
+      io = StringIO.new
+      io << YAML.dump({:one => 1, :two => 2, :three => 3})
+      io.seek 0
+
+      assert_raise(::Logging::Config::YamlConfigurator::Error) {
+        ::Logging::Config::YamlConfigurator.new(io, :meh)
+      }
+    end
+
+  end  # class TestYamlConfigurator
+
+end  # module TestConfig
+end  # module TestLogging
+
+# EOF

data/test/layouts/test_basic.rb

@@ -0,0 +1,42 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestBasic < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.basic({})
+      @levels = Logging::LEVELS
+    end
+
+    def test_format
+      event = Logging::LogEvent.new( 'ArrayLogger', @levels['info'],
+                                     'log message', false)
+      assert_equal " INFO  ArrayLogger : log message\n", @layout.format(event)
+
+      event.data = [1, 2, 3, 4]
+      assert_equal(" INFO  ArrayLogger : <Array> #{[1,2,3,4]}\n",
+                   @layout.format(event))
+
+      event.level = @levels['debug']
+      event.data = 'and another message'
+      log = "DEBUG  ArrayLogger : and another message\n"
+      assert_equal log, @layout.format(event)
+
+      event.logger = 'Test'
+      event.level = @levels['fatal']
+      event.data = Exception.new
+      log = "FATAL  Test : <Exception> Exception\n"
+      assert_equal log, @layout.format(event)
+    end
+
+  end  # class TestBasic
+
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/test/layouts/test_json.rb

@@ -0,0 +1,112 @@
+
+require File.join(File.dirname(__FILE__), %w[.. setup])
+
+module TestLogging
+module TestLayouts
+
+  class TestJson < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = Logging.layouts.json({})
+      @levels = Logging::LEVELS
+      @date_fmt = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+      Thread.current[:name] = nil
+    end
+
+    def test_initializer
+      assert_raise(ArgumentError) {
+        Logging.layouts.parseable.new :style => :foo
+      }
+    end
+
+    def test_format
+      fmt = %Q[\\{"timestamp":"#@date_fmt","level":"%s","logger":"%s","message":"%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_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/\{"timestamp":"#@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[{"logger":"TestLogger"}\n], @layout.format(event)
+
+      @layout.items = %w[file]
+      assert_equal %Q[{"file":"test_file.rb"}\n], @layout.format(event)
+
+      @layout.items = %w[level]
+      assert_equal %Q[{"level":"INFO"}\n], @layout.format(event)
+
+      @layout.items = %w[line]
+      assert_equal %Q[{"line":123}\n], @layout.format(event)
+
+      @layout.items = %w[message]
+      assert_equal %Q[{"message":"log message"}\n], @layout.format(event)
+
+      @layout.items = %w[method]
+      assert_equal %Q[{"method":"method_name"}\n], @layout.format(event)
+
+      @layout.items = %w[pid]
+      assert_match %r/\A\{"pid":\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[millis]
+      assert_match %r/\A\{"millis":\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread_id]
+      assert_match %r/\A\{"thread_id":-?\d+\}\n\z/, @layout.format(event)
+
+      @layout.items = %w[thread]
+      assert_equal %Q[{"thread":null}\n], @layout.format(event)
+      Thread.current[:name] = "Main"
+      assert_equal %Q[{"thread":"Main"}\n], @layout.format(event)
+    end
+
+  end  # class TestJson
+end  # module TestLayouts
+end  # module TestLogging
+
+# EOF

data/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