redcar 0.2.9dev

data/lib/logging/test/test_logging.rb

@@ -0,0 +1,267 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestLogging < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @levels = ::Logging::LEVELS
+      @lnames = ::Logging::LNAMES
+
+      @fn = File.join(TMP, 'test.log')
+      @glob = File.join(TMP, '*.log')
+    end
+
+    def test_backtrace
+      assert_equal true, ::Logging.backtrace
+
+      assert_equal false, ::Logging.backtrace('off')
+      assert_equal false, ::Logging.backtrace
+
+      assert_equal true, ::Logging.backtrace('on')
+      assert_equal true, ::Logging.backtrace
+
+      assert_equal false, ::Logging.backtrace(:off)
+      assert_equal false, ::Logging.backtrace
+
+      assert_equal true, ::Logging.backtrace(:on)
+      assert_equal true, ::Logging.backtrace
+
+      assert_equal false, ::Logging.backtrace(false)
+      assert_equal false, ::Logging.backtrace
+
+      assert_equal true, ::Logging.backtrace(true)
+      assert_equal true, ::Logging.backtrace
+
+      assert_raise(ArgumentError) {::Logging.backtrace 'foo'}
+    end
+
+    def test_configure
+      assert_raise(ArgumentError) {::Logging.configure 'blah.txt'}
+
+      ::Logging.configure 'data/logging.yaml'
+
+      names = %w[DEB INF PRT WRN ERR FAT]
+      assert_equal names, ::Logging::LNAMES
+      assert_equal :inspect, ::Logging::OBJ_FORMAT
+      assert_equal 3, ::Logging::Logger.root.level
+
+      # verify the appenders
+      h = ::Logging::Appenders.instance_variable_get :@appenders
+      assert_equal ['logfile', 'stderr'], h.keys.sort
+
+      # start with the File appender
+      logfile = ::Logging::Appenders['logfile']
+      assert_instance_of ::Logging::Appenders::File, logfile
+      assert_equal 0, logfile.level
+      assert_equal 'tmp/temp.log', logfile.instance_variable_get(:@fn)
+
+      layout = logfile.layout
+      assert_instance_of ::Logging::Layouts::Pattern, layout
+      assert_equal '[%d] %l  %c : %m\\n', layout.pattern
+      assert_equal 'to_s', layout.date_method
+      assert_nil layout.date_pattern
+
+      # and now the Stderr appender
+      stderr = ::Logging::Appenders['stderr']
+      assert_instance_of ::Logging::Appenders::Stderr, stderr
+      assert_equal 0, stderr.level
+
+      layout = stderr.layout
+      assert_instance_of ::Logging::Layouts::Basic, layout
+
+      # verify the loggers
+      h = ::Logging::Repository.instance.instance_variable_get :@h
+      assert_equal 4, h.length
+
+      # mylogger
+      mylogger = ::Logging::Logger['mylogger']
+      assert_equal 0, mylogger.level
+      assert_equal false, mylogger.additive
+      assert_equal false, mylogger.trace
+
+      appenders = mylogger.instance_variable_get :@appenders
+      assert_equal 2, appenders.length
+      assert_equal ['logfile', 'stderr'], appenders.map {|a| a.name}.sort
+
+      # yourlogger
+      yourlogger = ::Logging::Logger['yourlogger']
+      assert_equal 1, yourlogger.level
+      assert_equal true, yourlogger.additive
+      assert_equal false, yourlogger.trace
+
+      appenders = yourlogger.instance_variable_get :@appenders
+      assert_equal 2, appenders.length
+      assert_equal ['logfile', 'stderr'], appenders.map {|a| a.name}.sort
+    end
+
+    def test_logger
+      assert_raise(TypeError) {::Logging.logger []}
+
+      logger = ::Logging.logger STDOUT
+      assert_match %r/\A-?\d+\z/, logger.name
+      assert_same logger, ::Logging.logger(STDOUT)
+
+      logger.close
+      assert !STDOUT.closed?
+
+      assert !File.exist?(@fn)
+      fd = File.new @fn, 'w'
+      logger = ::Logging.logger fd, 2, 100
+      assert_equal @fn, logger.name
+      logger.debug 'this is a debug message'
+      logger.warn 'this is a warning message'
+      logger.error 'and now we should have over 100 bytes of data ' +
+                   'in the log file'
+      logger.info 'but the log file should not roll since we provided ' +
+                  'a file descriptor -- not a file name'
+      logger.close
+      assert fd.closed?
+      assert File.exist?(@fn)
+      assert_equal 1, Dir.glob(@glob).length
+
+      FileUtils.rm_f @fn
+      assert !File.exist?(@fn)
+      logger = ::Logging.logger @fn, 2, 100
+      assert File.exist?(@fn)
+      assert_equal @fn, logger.name
+      logger.debug 'this is a debug message'
+      logger.warn 'this is a warning message'
+      logger.error 'and now we should have over 100 bytes of data ' +
+                   'in the log file'
+      logger.info 'but the log file should not roll since we provided ' +
+                  'a file descriptor -- not a file name'
+      logger.close
+      assert_equal 3, Dir.glob(@glob).length
+    end
+
+    def test_init_default
+      assert_equal({}, @levels)
+      assert_equal([], @lnames)
+      assert_same false, ::Logging.const_defined?(:MAX_LEVEL_LENGTH)
+
+      ::Logging::Repository.instance
+
+      assert_equal 5, @levels.length
+      assert_equal 5, @lnames.length
+      assert_equal 5, ::Logging::MAX_LEVEL_LENGTH
+
+      assert_equal 0, @levels['debug']
+      assert_equal 1, @levels['info']
+      assert_equal 2, @levels['warn']
+      assert_equal 3, @levels['error']
+      assert_equal 4, @levels['fatal']
+
+      assert_equal 'DEBUG', @lnames[0]
+      assert_equal 'INFO',  @lnames[1]
+      assert_equal 'WARN',  @lnames[2]
+      assert_equal 'ERROR', @lnames[3]
+      assert_equal 'FATAL', @lnames[4]
+    end
+
+    def test_init_special
+      assert_equal({}, @levels)
+      assert_equal([], @lnames)
+      assert_same false, ::Logging.const_defined?(:MAX_LEVEL_LENGTH)
+
+      assert_raise(ArgumentError) {::Logging.init(1, 2, 3, 4)}
+
+      ::Logging.init :one, 'two', :THREE, 'FoUr', :sIx
+
+      assert_equal 5, @levels.length
+      assert_equal 5, @lnames.length
+      assert_equal 5, ::Logging::MAX_LEVEL_LENGTH
+
+      assert_equal 0, @levels['one']
+      assert_equal 1, @levels['two']
+      assert_equal 2, @levels['three']
+      assert_equal 3, @levels['four']
+      assert_equal 4, @levels['six']
+
+      assert_equal 'ONE',   @lnames[0]
+      assert_equal 'TWO',   @lnames[1]
+      assert_equal 'THREE', @lnames[2]
+      assert_equal 'FOUR',  @lnames[3]
+      assert_equal 'SIX',   @lnames[4]
+    end
+
+    def test_init_all_off
+      assert_equal({}, @levels)
+      assert_equal([], @lnames)
+      assert_same false, ::Logging.const_defined?(:MAX_LEVEL_LENGTH)
+
+      ::Logging.init %w(a b all c off d)
+
+      assert_equal 4, @levels.length
+      assert_equal 4, @lnames.length
+      assert_equal 3, ::Logging::MAX_LEVEL_LENGTH
+
+      assert_equal 0, @levels['a']
+      assert_equal 1, @levels['b']
+      assert_equal 2, @levels['c']
+      assert_equal 3, @levels['d']
+
+      assert_equal 'A', @lnames[0]
+      assert_equal 'B', @lnames[1]
+      assert_equal 'C', @lnames[2]
+      assert_equal 'D', @lnames[3]
+    end
+
+    def test_format_as
+      assert_equal false, ::Logging.const_defined?('OBJ_FORMAT')
+
+      assert_raises(ArgumentError) {::Logging.format_as 'bob'}
+      assert_raises(ArgumentError) {::Logging.format_as String}
+      assert_raises(ArgumentError) {::Logging.format_as :what?}
+      
+      remove_const = lambda do |const|
+        ::Logging.class_eval {remove_const const if const_defined? const}
+      end
+
+      ::Logging.format_as :string
+      assert ::Logging.const_defined?('OBJ_FORMAT')
+      assert_equal :string, ::Logging::OBJ_FORMAT
+      remove_const[:OBJ_FORMAT]
+
+      ::Logging.format_as :inspect
+      assert ::Logging.const_defined?('OBJ_FORMAT')
+      assert_equal :inspect, ::Logging::OBJ_FORMAT
+      remove_const[:OBJ_FORMAT]
+
+      ::Logging.format_as :yaml
+      assert ::Logging.const_defined?('OBJ_FORMAT')
+      assert_equal :yaml, ::Logging::OBJ_FORMAT
+      remove_const[:OBJ_FORMAT]
+
+      ::Logging.format_as 'string'
+      assert ::Logging.const_defined?('OBJ_FORMAT')
+      assert_equal :string, ::Logging::OBJ_FORMAT
+      remove_const[:OBJ_FORMAT]
+
+      ::Logging.format_as 'inspect'
+      assert ::Logging.const_defined?('OBJ_FORMAT')
+      assert_equal :inspect, ::Logging::OBJ_FORMAT
+      remove_const[:OBJ_FORMAT]
+
+      ::Logging.format_as 'yaml'
+      assert ::Logging.const_defined?('OBJ_FORMAT')
+      assert_equal :yaml, ::Logging::OBJ_FORMAT
+      remove_const[:OBJ_FORMAT]
+    end
+
+    def test_path
+      path = ::Logging.path(*%w[one two three])
+      assert_match %r/one\/two\/three$/, path
+    end
+
+    def test_version
+      assert_match %r/\d+\.\d+\.\d+/, ::Logging.version
+    end
+
+  end  # class TestLogging
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/test_repository.rb

@@ -0,0 +1,158 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestRepository < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @repo = ::Logging::Repository.instance
+    end
+
+    def test_instance
+      assert_same @repo, ::Logging::Repository.instance
+    end
+
+    def test_aref
+      root = @repo[:root]
+      assert_same root, @repo[:root]
+
+      a = []
+      ::Logging::Logger.new a
+      assert_same @repo['Array'], @repo[Array]
+      assert_same @repo['Array'], @repo[a]
+
+      assert_not_same @repo['Array'], @repo[:root]
+
+      ::Logging::Logger.new 'A'
+      ::Logging::Logger.new 'A::B'
+      assert_not_same @repo['A'], @repo['A::B']
+    end
+
+    def test_aset
+      root = @repo[:root]
+      @repo[:root] = 'root'
+      assert_not_same root, @repo[:root]
+
+      assert_nil @repo['blah']
+      @repo['blah'] = 'root'
+      assert_equal 'root', @repo['blah']
+    end
+
+    def test_fetch
+      assert @repo.has_logger?(:root)
+      assert_same @repo[:root], @repo.fetch(:root)
+
+      assert !@repo.has_logger?('A')
+      assert_raise(KeyError) {@repo.fetch 'A'}
+
+      %w(A A::B A::B::C::D A::B::C::E A::B::C::F).each do |name|
+        ::Logging::Logger.new(name)
+      end
+
+      assert @repo.has_logger?('A')
+      assert @repo.has_logger?('A::B')
+    end
+
+    def test_parent
+      %w(A A::B A::B::C::D A::B::C::E A::B::C::F).each do |name|
+        ::Logging::Logger.new(name)
+      end
+
+      assert_same @repo[:root], @repo.parent('A')
+      assert_same @repo['A'], @repo.parent('A::B')
+      assert_same @repo['A::B'], @repo.parent('A::B::C')
+      assert_same @repo['A::B'], @repo.parent('A::B::C::D')
+      assert_same @repo['A::B'], @repo.parent('A::B::C::E')
+      assert_same @repo['A::B'], @repo.parent('A::B::C::F')
+
+      ::Logging::Logger.new('A::B::C')
+
+      assert_same @repo['A::B'], @repo.parent('A::B::C')
+      assert_same @repo['A::B::C'], @repo.parent('A::B::C::D')
+      assert_same @repo['A::B::C'], @repo.parent('A::B::C::E')
+      assert_same @repo['A::B::C'], @repo.parent('A::B::C::F')
+
+      ::Logging::Logger.new('A::B::C::E::G')
+
+      assert_same @repo['A::B::C::E'], @repo.parent('A::B::C::E::G')
+
+      assert_nil @repo.parent('root')
+    end
+
+    def test_children
+      ::Logging::Logger.new('A')
+
+      assert_equal [], @repo.children('A')
+
+      ::Logging::Logger.new('A::B')
+      a = %w(D E F).map {|name| ::Logging::Logger.new('A::B::C::'+name)}.sort
+
+      assert_equal [@repo['A::B']], @repo.children('A')
+      assert_equal a, @repo.children('A::B')
+      assert_equal [], @repo.children('A::B::C')
+
+      ::Logging::Logger.new('A::B::C')
+
+      assert_equal [@repo['A::B::C']], @repo.children('A::B')
+      assert_equal a, @repo.children('A::B::C')
+
+      ::Logging::Logger.new('A::B::C::E::G')
+
+      assert_equal a, @repo.children('A::B::C')
+      assert_equal [@repo['A::B::C::E::G']], @repo.children('A::B::C::E')
+
+      assert_equal [@repo['A'], @repo['Logging']], @repo.children('root')
+    end
+
+    def test_to_key
+      assert_equal :root, @repo.to_key(:root)
+      assert_equal 'Object', @repo.to_key('Object')
+      assert_equal 'Object', @repo.to_key(Object)
+      assert_equal 'Object', @repo.to_key(Object.new)
+
+      assert_equal 'String', @repo.to_key(String)
+      assert_equal 'Array', @repo.to_key([])
+
+      assert_equal 'blah', @repo.to_key('blah')
+      assert_equal 'blah', @repo.to_key(:blah)
+    end
+
+    def test_add_master
+      ary = @repo.instance_variable_get(:@masters)
+      assert true, ary.empty?
+
+      @repo.add_master 'root'
+      assert_equal [:root], ary
+
+      @repo.add_master Object, 'Foo'
+      assert_equal [:root, 'Object', 'Foo'], ary
+    end
+
+    def test_master_for
+      assert_nil @repo.master_for('root')
+      assert_nil @repo.master_for('Foo::Bar::Baz')
+
+      @repo.add_master('Foo')
+      assert_equal 'Foo', @repo.master_for('Foo')
+      assert_equal 'Foo', @repo.master_for('Foo::Bar::Baz')
+
+      @repo.add_master('Foo::Bar::Baz')
+      assert_equal 'Foo', @repo.master_for('Foo')
+      assert_equal 'Foo', @repo.master_for('Foo::Bar')
+      assert_equal 'Foo::Bar::Baz', @repo.master_for('Foo::Bar::Baz')
+      assert_equal 'Foo::Bar::Baz', @repo.master_for('Foo::Bar::Baz::Buz')
+
+      assert_nil @repo.master_for('Bar::Baz::Buz')
+      @repo.add_master 'root'
+      assert_equal :root, @repo.master_for('Bar::Baz::Buz')
+      assert_equal 'Foo', @repo.master_for('Foo::Bar')
+      assert_equal 'Foo::Bar::Baz', @repo.master_for('Foo::Bar::Baz::Buz')
+    end
+
+  end  # class TestRepository
+end  # module TestLogging
+
+# EOF

data/lib/logging/test/test_root_logger.rb

@@ -0,0 +1,81 @@
+
+require File.join(File.dirname(__FILE__), %w[setup])
+
+module TestLogging
+
+  class TestRootLogger < Test::Unit::TestCase
+    include LoggingTestCase
+
+    def setup
+      super
+      @root = ::Logging::Logger.root
+    end
+
+    def test_additive
+      assert_raise(NoMethodError) {@root.additive}
+    end
+
+    def test_additive_eq
+      assert_raise(NoMethodError) {@root.additive = true}
+    end
+
+    def test_level_eq
+      assert_equal 0, @root.level
+
+      assert_raise(ArgumentError) {@root.level = -1}
+      assert_raise(ArgumentError) {@root.level =  6}
+      assert_raise(ArgumentError) {@root.level = Object}
+      assert_raise(ArgumentError) {@root.level = 'bob'}
+      assert_raise(ArgumentError) {@root.level = :wtf}
+
+      @root.level = 'INFO'
+      assert_equal 1, @root.level
+
+      @root.level = :warn
+      assert_equal 2, @root.level
+
+      @root.level = 'error'
+      assert_equal 3, @root.level
+
+      @root.level = 4
+      assert_equal 4, @root.level
+
+      @root.level = :all
+      assert_equal 0, @root.level
+
+      @root.level = 'OFF'
+      assert_equal 5, @root.level
+
+      @root.level = nil
+      assert_equal 0, @root.level
+    end
+
+    def test_name
+      assert_equal 'root', @root.name
+    end
+
+    def test_parent
+      assert_raise(NoMethodError) {@root.parent}
+    end
+
+    def test_parent_eq
+      assert_raise(NoMethodError) {@root.parent = nil}
+    end
+
+    def test_spaceship
+      logs = %w(
+        A  A::B  A::B::C  A::B::C::D  A::B::C::E  A::B::C::E::G  A::B::C::F
+      ).map {|x| ::Logging::Logger[x]}
+
+      logs.each do |log|
+        assert_equal(-1, @root <=> log, "'root' <=> '#{log.name}'")
+      end
+
+      assert_equal 0, @root <=> @root
+      assert_raise(ArgumentError) {@root <=> 'string'}
+    end
+
+  end  # class TestRootLogger
+end  # module TestLogging
+
+# EOF