sgeorgi-logging 1.4.2

data/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/test/setup.rb

@@ -0,0 +1,43 @@
+
+# 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'
+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/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

data/test/test_consolidate.rb

@@ -0,0 +1,46 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestConsolidate < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def test_root
+      Logging.consolidate :root
+      root = Logging.logger.root
+
+      assert_same root, Logging.logger['Foo']
+      assert_same root, Logging.logger['Foo::Bar']
+      assert_same root, Logging.logger[Array]
+    end
+
+    def test_foo
+      Logging.consolidate 'Foo'
+      logger = Logging.logger['Foo::Bar::Baz']
+
+      assert_same Logging.logger['Foo'], logger
+      assert_not_same Logging.logger.root, logger
+    end
+
+    def test_many
+      Logging.consolidate 'Foo', 'root', 'Foo::Bar::Baz'
+
+      root = Logging.logger.root
+      foo = Logging.logger['Foo']
+      fbb = Logging.logger['Foo::Bar::Baz']
+
+      assert_not_same root, foo
+      assert_not_same root, fbb
+      assert_not_same foo, fbb
+
+      assert_same root, Logging.logger[Hash]
+      assert_same root, Logging.logger['ActiveRecord::Base']
+      assert_same foo, Logging.logger['Foo::Bar']
+      assert_same fbb, Logging.logger['Foo::Bar::Baz::Buz']
+    end
+
+  end  # class TestConsolidate
+end  # module TestLogging
+
+# EOF

data/test/test_layout.rb

@@ -0,0 +1,110 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestLayout < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @layout = ::Logging::Layout.new
+    end
+
+    def test_header
+      assert_equal '', @layout.header
+    end
+
+    def test_initialize
+      obj_format = lambda {|l| l.instance_variable_get :@obj_format}
+
+      assert_equal :string, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new 'format_as' => 'blah'
+      assert_equal :string, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new :format_as => :inspect
+      assert_equal :inspect, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new 'format_as' => :yaml
+      assert_equal :yaml, obj_format[@layout]
+
+      @layout = ::Logging::Layout.new
+      assert_equal :string, obj_format[@layout]
+
+      ::Logging.format_as :yaml
+      @layout = ::Logging::Layout.new
+      assert_equal :yaml, obj_format[@layout]
+    end
+
+    def test_footer
+      assert_equal '', @layout.footer
+    end
+
+    def test_format
+      assert_nil @layout.format(::Logging::LogEvent.new('a','b','c',false))
+    end
+
+    def test_format_obj
+      obj = 'test string'
+      r = @layout.format_obj obj
+      assert_same obj, r
+
+      obj = RuntimeError.new
+      r = @layout.format_obj obj
+      assert_equal '<RuntimeError> RuntimeError', r
+
+      obj = TypeError.new 'only works with Integers'
+      r = @layout.format_obj obj
+      assert_equal '<TypeError> only works with Integers', r
+
+      obj = Exception.new 'some exception'
+      obj.set_backtrace %w( this is the backtrace )
+      r = @layout.format_obj obj
+      obj = "<Exception> some exception\n\tthis\n\tis\n\tthe\n\tbacktrace"
+      assert_equal obj, r
+
+      obj = [1, 2, 3, 4]
+      r = @layout.format_obj obj
+      assert_equal "<Array> #{[1,2,3,4]}", r
+
+      obj = %w( one two three four )
+      @layout = ::Logging::Layout.new :format_as => :inspect
+      r = @layout.format_obj obj
+      assert_equal '<Array> ["one", "two", "three", "four"]', r
+
+      @layout = ::Logging::Layout.new :format_as => :yaml
+      r = @layout.format_obj obj
+      assert_equal "<Array> \n--- \n- one\n- two\n- three\n- four\n", r
+      
+      r = @layout.format_obj Class
+      assert_equal "<Class> Class", r
+    end
+
+    def test_format_obj_without_backtrace
+      @layout = ::Logging::Layout.new :backtrace => 'off'
+
+      obj = Exception.new 'some exception'
+      obj.set_backtrace %w( this is the backtrace )
+      r = @layout.format_obj obj
+      obj = "<Exception> some exception"
+      assert_equal obj, r
+
+      ::Logging.backtrace :off
+      @layout = ::Logging::Layout.new
+
+      obj = ArgumentError.new 'wrong type of argument'
+      obj.set_backtrace %w( this is the backtrace )
+      r = @layout.format_obj obj
+      obj = "<ArgumentError> wrong type of argument"
+      assert_equal obj, r
+    end
+
+    def test_initializer
+      assert_raise(ArgumentError) {::Logging::Layout.new :backtrace => 'foo'}
+    end
+
+  end  # class TestLayout
+end  # module TestLogging
+
+# EOF