minitest-logger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d51ed75e12126c8c39f3f715b74a00244cc19082
+  data.tar.gz: 062e383d2514d4aee2abe2c3ad6f3dfdc5d0e6cd
+SHA512:
+  metadata.gz: 2503ff04c3bcb419ecd9c44faf9d81a770be1955c032eda5d5446d197b9a2aea7a8ac090ee375f51e325775fdf24d43a1172778568b443ae6035fbf2f6afaa21
+  data.tar.gz: 9f2ce36be94e06bf4d645f390075a607e78a5b6fc48f7ea95970edeb7c9b65f80a5b855af2c4772cc028e284e0d607a0d702e287ee20c9feedcd3f5e35916c84

data/examples/example_assertions.rb

@@ -0,0 +1,104 @@
+#encoding: utf-8
+=begin rdoc
+Example for usage of gem minitest-logger.
+
+See also the unit tests for more variants.
+=end
+
+=begin
+You may use two different loggers:
+=end
+require 'log4r'
+require 'logger'
+
+$:.unshift('../lib')
+require 'minitest-logger'
+
+=begin rdoc
+Example of the usage of Minitest-Logger-Gem.
+
+Module TestExamples defined testcases to be used with Logger and Log4r::Logger-instances.
+
+The methods expect an attribute @log.
+=end
+module TestExamples
+    
+  #Test if logger output is made
+  #
+  #The Methods #test_output_1, #test_output_2 and #test_output_3 are the same test 
+  #with different method to define a string
+  def test_output_1 
+    assert_log(" INFO log: Hello World\n"){ @log.info("Hello World") }
+  end
+  #See #test_output_1
+  def test_output_2
+    assert_log(<<LOG  ){ @log.info("Hello World") }
+ INFO log: Hello World
+LOG
+  end
+  #See #test_output_1
+  def test_output_3
+    assert_log(<<LOG
+ INFO log: Hello World
+LOG
+      ){ @log.info("Hello World") }
+  end
+  #Test the logger message with a regexp.
+  #
+  #This may be usefull for logger messages with timestamps.
+  def test_output_regex
+    assert_log(/Hello World/){ @log.info("Hello World") }
+  end
+
+  def test_output_with_comment
+    assert_log(" INFO log: Hello World\n"){ @log.info("Hello World") }
+    assert_log(" INFO log: Hello World\n", 'This Logger logs unexpected messages'){ @log.info("Hello World") }
+  end
+
+
+  def test_no_message # :nodoc:
+    assert_log(nil){ @log.debug("Hello World") }
+    assert_log(nil, 'Log is not silent'){ @log.debug("Hello World")}
+  end
+
+  #test for (non) silent logger
+  def test_silent
+    assert_silent_log(){
+      @log.debug("Hello World")
+      #~ @log.info("Hello World")     #uncomment this to see a failure
+    }
+    refute_silent_log(){
+      @log.warn("Hello World")     #comment this to see a failure
+    }
+  end
+
+=begin rdoc
+Make tests of Module TestExamples with Log4r::Logger-instance.
+=end
+  class Test_log4r < MiniTest::Test
+    include TestExamples
+    def setup # :nodoc:
+      @log = Log4r::Logger.new('log')
+      @log.level = Log4r::INFO
+      #~ @log.level = Log4r::WARN
+    end    
+  end
+
+=begin rdoc
+Make tests of Module TestExamples with Logger-instance.
+=end
+  class Test_logger < MiniTest::Test
+    include TestExamples
+    def setup # :nodoc:
+      #~ @log = Logger.new(STDOUT)
+      @log = Logger.new(IO.new(File::RDONLY,'w'))
+      @log.level = Logger::INFO
+      #Adapt logger output to Log4r-format. So we can reuses the testcases in TestExamples
+      @log.formatter = proc{ |serverity, time, progname, msg|
+          "%5s log: %s\n" % [serverity, msg]
+      }
+    end
+  end
+end #module TestExamples
+
+__END__

data/examples/example_specification.rb

@@ -0,0 +1,69 @@
+#encoding: utf-8
+=begin rdoc
+Tests for minitest-logger
+=end 
+$:.unshift('../lib')
+
+require 'log4r'
+require 'logger'
+require 'minitest-logger'
+
+=begin
+Log4r::Logger
+=end
+describe Log4r::Logger do
+  before do
+    @log = Log4r::Logger.new('log')
+    @log.level = Log4r::INFO
+  end
+
+  describe "When a debug-message is posted" do
+    it "must not be reported" do
+      lambda{ @log.debug('Hello World') }.must_log(nil)
+    end
+    it "must not be reported, even if we set the level to debug" do
+      lambda{ @log.debug('Hello World')}.must_log( nil, :level => Log4r::DEBUG)
+    end
+  end
+  
+  describe "When a info-message is posted" do
+    it "must be reported" do
+      lambda{ @log.info('Hello World')}.must_log( " INFO log: Hello World\n", :level => Log4r::INFO)
+    end
+    
+    it "must be not reported if we set the level to warn" do
+      lambda{ @log.info('Hello World')}.must_log( nil, :level => Log4r::WARN)
+    end
+  end
+
+end
+
+=begin
+Logger
+=end
+describe Logger do
+  before do
+    @log = Logger.new('log')
+    @log.level = Logger::INFO
+  end
+
+  describe "When a debug-message is posted" do
+    it "must not be reported" do
+      lambda{ @log.debug('Hello World') }.must_log(nil)
+    end
+    it "must not be reported, even if we set the level to debug" do
+      lambda{ @log.debug('Hello World')}.must_log( nil, :level => Logger::DEBUG)
+    end
+  end
+  
+  describe "When a info-message is posted" do
+    it "must be reported" do
+      lambda{ @log.info('Hello World')}.must_log( /I, \[.*\]  INFO -- : Hello World\n/, :level => Logger::INFO)
+    end
+    
+    it "must be not reported if we set the level to warn" do
+      lambda{ @log.info('Hello World')}.must_log( nil, :level => Logger::WARN)
+    end
+  end
+
+end

data/lib/minitest-logger.rb

@@ -0,0 +1,249 @@
+#encoding: utf-8
+=begin rdoc
+Gem Minitest-Logger-Gem is the result of a question at Stackoverflow:
+http://stackoverflow.com/questions/29392292/how-can-i-test-logger-messages-with-minitest
+
+It extends Minitest::Test by Minitest::Assertion#assert_log.
+
+With Minitest::Assertion#assert_log you can check,
+if you get the Logger-messages you expect.
+
+
+=Usage
+==Load the gem
+There are 3 methods to load the gem:
+
+If you use Log4r:
+
+  require 'minitest/log4r'
+
+If you use Logger:
+
+  require 'minitest/logger'
+
+Alterative you can use - after you required log4r and/or logger:
+
+  require 'minitest-logger'
+
+==Make a testcase
+
+During Test#setup you must define @log, then you can test the logs.
+
+  class Test_log4r < MiniTest::Test
+    def setup
+      @log = Log4r::Logger.new('log')
+      @log.level = Log4r::INFO
+    end
+    
+    def test_logger
+      assert_log(" INFO log: Hello World\n"){ @log.info("Hello World") }
+    end
+  end
+  
+More details see examples/example_minitest-logger.rb and the unit tests.
+
+==Make Specifications
+Example:
+
+  describe Log4r::Logger do
+    before do
+      @log = Log4r::Logger.new('log')
+      @log.level = Log4r::INFO
+    end
+
+    describe "When a info-message is posted" do
+      it "must be reported" do
+        lambda{ @log.info('Hello World')}.must_log( " INFO log: Hello World\n", :level => Log4r::INFO)
+      end
+      
+      it "must be not reported if we set the level to warn" do
+        lambda{ @log.info('Hello World')}.must_log( nil, :level => Log4r::WARN)
+      end
+    end
+  end
+
+More details see examples and the unit tests.
+
+=Related stuff
+
+You may also be interested in:
+* http://9astronauts.com/code/rails-plugins/testable-logger/
+=end
+
+gem 'minitest'
+require 'minitest/autorun'
+
+=begin rdoc
+Check if Log4r or Logger is available.
+
+If yes, load the corresponding minitest version.
+=end
+if Object.const_defined? 'Log4r'
+  require_relative 'minitest/log4r'
+end
+if Object.const_defined? 'Logger'
+  require_relative 'minitest/logger'
+end
+
+if ! ( Object.const_defined? 'Log4r' or Object.const_defined? 'Logger')
+  raise LoadError, <<msg
+No Logger defined. 
+Load first log4r/logger or use
+  require 'minitest/log4r'
+or
+  require 'minitest/logger"
+msg
+end
+
+module Minitest
+=begin rdoc
+It is recommended to define the logger in Minitest::Test#setup:
+
+Example:
+
+  class Test_logger < MiniTest::Test
+    def setup # :nodoc:
+      @testee = Testee.new(...)
+      @log = @testee.log
+    end
+    ...
+  end
+=end  
+  class Test
+      #define the logger for Assertions#assert_log.
+      #It is recommended to define the logger in #setup or as an option of Assertions#assert_log
+      attr_accessor :log
+  end
+    
+  Logger_VERSION = '0.1.0'
+  module Assertions
+=begin rdoc
+Evaluate block and collect the messages of a logger.
+
+==Argument level:
+This enables you to test less messages (e.g. only errors) without the need
+of adapt the logger itself.
+
+Attention: The level of the logger has a higher priority the the level of the outputter.
+If the logger logs no DEBUG-messages, the output will also be empty, 
+independent of the value of this parameter.
+=end
+    def logger_evaluation(log, level=nil)
+      raise ArgumentError unless defined? log
+      raise ArgumentError unless block_given?
+      
+      case log.class.to_s
+        when 'Log4r::Logger'
+          log.outputters << outputter = Log4r::StringOutputter.new('stringoutputter') 
+          outputter.level = level if level
+        when 'Logger'
+          log.catch_messages(level)
+        end
+      yield #call block to get messages
+      case log.class.to_s
+        when 'Log4r::Logger'
+          logtext = outputter.flush
+        when 'Logger'
+          logtext = log.catch_messages_stop()
+        end      
+      return logtext
+    end #logger_evaluation
+=begin rdoc
+
+==Options
+===Define test logger (:log)
+With option :log you can define or replace the logger to test.
+
+It is recommended to define the logger during setup in Minitest::Test.
+
+===Define log level (:level)
+With option :level you can set an alternative level for the test.
+
+See also #logger_evaluation for more information
+
+==Examples
+
+    assert_log(" INFO log: Hello World\n"){ @log.info("Hello World") }
+    assert_log(" INFO log: Hello World\n", :log => @log){ @log.info("Hello World") }
+    assert_log(" INFO log: Hello World\n", :level => Log4r::INFO){ @log.info("Hello World") }
+    assert_log(nil, :level => Log4r::WARN){ @log.info("Hello World") }
+    
+
+      msg = message(msg, E) { diff exp, act }
+      assert exp == act, msg
+      
+=end
+
+    def assert_log(expected, msg=nil, options = {}, &block)
+      if msg.is_a?(Hash)
+        options = msg
+        msg = nil
+      end
+
+      logtext = logger_evaluation(options[:log] || @log, options[:level], &block)
+        
+      err_msg = Regexp === expected ? :assert_match : :assert_equal
+      send err_msg, expected, logtext, message(msg) { "Logger #{options[:log] || @log} logs unexpected messages" } 
+    end
+=begin rdoc
+Test for silent log (No messages are returned).
+
+For details on options see #assert_log and #logger_evaluation
+=end
+    def assert_silent_log(msg=nil, options = {}, &block)
+      if msg.is_a?(Hash)
+        options = msg
+        msg = nil
+      end
+      
+      logtext = logger_evaluation(options[:log] || @log, options[:level], &block)
+      assert !logtext, message(msg) { "Expected #{options[:log] || @log} to be silent, but returned\n #{mu_pp(logtext)}" }
+    end
+=begin rdoc
+Test for silent log (No messages are returned)
+
+For details on options see #assert_log and #logger_evaluation
+=end
+    def refute_silent_log(msg=nil, options = {}, &block)
+      if msg.is_a?(Hash)
+        options = msg
+        msg = nil
+      end
+      logtext = logger_evaluation(options[:log] || @log, options[:level], &block)
+      
+      assert logtext, message(msg) { "Expected #{options[:log] || @log} not to be silent" }
+    end #assert_silent_log
+    
+  end #module Assertions
+
+=begin rdoc
+Tests via Specs.
+=end
+  module Expectations
+    ##
+    # See Minitest::Assertions#assert_log
+    #
+    # Usage:
+    #    lambda { ... }.must_log( messagestring [, options])
+    #
+    # :method: must_log
+    infect_an_assertion :assert_log, :must_log
+    ##
+    # See Minitest::Assertions#assert_silent_log
+    #
+    # Usage:
+    #    lambda { ... }.must_silent_log( messagestring [, options])
+    #
+    # :method: must_silent_log
+    infect_an_assertion :assert_silent_log, :must_silent_log
+    ##
+    # See Minitest::Assertions#refute_silent_log
+    #
+    # Usage:
+    #    lambda { ... }.must_not_silent_log( messagestring [, options])
+    #
+    # :method: must_not_silent_log
+    infect_an_assertion :refute_silent_log, :must_not_silent_log
+  end #module Expectations
+end #Minitest
+

data/lib/minitest/log4r.rb

@@ -0,0 +1,32 @@
+#encoding: utf-8
+=begin rdoc
+Extend Minitest with tests for log4r.
+=end
+  
+require 'log4r'  #
+require_relative '../minitest-logger'
+
+module Log4r
+=begin rdoc
+Define a new Log4r-outputter to catch data into an String.
+=end
+  class StringOutputter < Log4r::StdoutOutputter
+=begin rdoc
+Collect messages in array.
+=end
+    def write(message)
+      @messages ||= ''  #create with first call
+      @messages  << message
+    end
+=begin rdoc
+Clear message string and return messages.
+=end
+    def flush
+      @messages ||= ''  #create with first call
+      messages = @messages.dup
+      @messages = ''
+      messages.empty? ? nil : messages
+    end
+  end #ArrayOutputter
+    
+end

data/lib/minitest/logger.rb

@@ -0,0 +1,55 @@
+#encoding: utf-8
+=begin rdoc
+Extend Logger with features to catch messages.
+=end
+  
+require 'logger'  #
+require_relative '../minitest-logger'
+
+=begin rdoc
+Extend Logger by #catch_messages and #catch_messages_stop to 
+store logger messages for later evaluation.
+Idea based on http://stackoverflow.com/a/12658810/676874
+
+This is used for Logger-instances in Minitest::Assertions#assert_log
+
+=end
+class Logger
+  # Collect all messages for later evaluation.
+  def catch_messages(level)
+    @logdev.catch_messages(level)
+  end
+
+  # Stop message collection and retund the collected messages.
+  def catch_messages_stop()
+    @logdev.catch_messages_stop()
+  end
+
+  class LogDevice # :nodoc:
+
+    # Define a String to collect messages.
+    def catch_messages(level)
+      @catchlevel = level
+      @messages = ''
+    end
+
+    # Stop message collection and retund the collected messages.
+    def catch_messages_stop()
+      messages = @messages
+      @messages = nil
+      messages.empty? ? nil : messages
+    end
+    
+    LEVELS = %w{debug info warn error fatal unknown}
+    alias_method :old_write, :write
+    #Store messages also in @messages if requested.
+    def write(message)
+      #check level with @catchlevel 
+      if @messages 
+        caller[1] =~ /`(.+?)'\Z/
+        @messages << message if !@catchlevel  or @catchlevel <= LEVELS.index($1)
+      end
+      old_write(message)
+    end
+  end #LogDevice 
+end

data/rakefile_minitest-logger.rb

@@ -0,0 +1,104 @@
+#encoding: utf-8
+=begin
+Create gem minitest-logger
+
+Idea for further development:
+Collect only errors/warnings....:
++ assert_error
++ assert_warn
+
+=end
+require 'knut-gempackager'  
+
+require '../knut_pw.rb'
+$:.unshift('lib')
+require 'minitest-logger'
+$minitest_logger_version = "0.1.0"
+
+#http://docs.rubygems.org/read/chapter/20
+gem_minitest_logger = Knut::Gem_packer.new('minitest-logger', $minitest_logger_version){ |gemdef, s|
+  s.name = "minitest-logger"
+  s.version =  $minitest_logger_version
+  s.author = "Knut Lickert"
+  s.email = "knut@lickert.net"
+  #~ s.homepage = "http://ruby.lickert.net/minitest-logger"
+  #~ s.homepage = "http://gems.rubypla.net/minitest-logger"
+  #~ s.rubyforge_project = 'minitest-logger'
+  s.platform = Gem::Platform::RUBY
+  #~ s.required_ruby_version = '>= 1.9'
+  #~ s.license = '?'
+  s.summary = "Extend minitest by assert_log"
+  s.description = <<-DESCR
+Extend minitest by assert_log and enable minitest to test log messages.
+Supports Logger and Log4r::Logger.
+  DESCR
+  s.require_path = "lib"
+  s.files = %w{
+    rakefile_minitest-logger.rb
+    lib/minitest-logger.rb
+    lib/minitest/log4r.rb
+    lib/minitest/logger.rb
+    examples/example_assertions.rb
+    examples/example_specification.rb
+  }
+  s.test_files    = %w{
+    unittest/test_load_minitest-logger.rb
+    unittest/test_minitest-logger.rb
+    unittest/test_minitest-log4r.rb
+  }
+  #~ s.test_files   << Dir['unittest/expected/*']
+  s.test_files.flatten!
+
+  #~ s.bindir = "bin"
+  #~ s.executables << 'minitest-logger.rb'
+
+  s.rdoc_options << '--main lib/minitest-logger.rb'
+  s.rdoc_options << '--title "Rdoc: Minitest-logger"'
+  s.extra_rdoc_files = %w{
+    examples/example_assertions.rb
+    examples/example_specification.rb
+  }
+  
+  #~ s.add_dependency('') 
+  s.add_dependency('minitest','>= 0') #tested with "5.5.1" (rb1.9.3 + rb 2.1.5)
+  #~ s.add_dependency('log4r')
+  
+  #~ s.add_development_dependency()
+  s.requirements << 'Log4r or Logger'
+
+  gemdef.public = true
+  #~ gemdef.add_ftp_connection('ftp.rubypla.net', Knut::FTP_RUBYPLANET_USER, Knut::FTP_RUBYPLANET_PW, "/Ruby/gemdocs/minitest-logger/#{$minitest_logger_version}")
+
+  gemdef.define_test( 'unittest', FileList['test_load*.rb'])
+  gemdef.define_test( 'unittest', FileList['test_minitest*.rb'])
+  gemdef.versions << Minitest::Logger_VERSION 
+
+}
+
+#generate rdoc
+task :rdoc_local do
+  FileUtils.rm_r('doc') if File.exist?('doc')
+  cmd = ["rdoc -f hanna"]
+  cmd << gem_minitest_logger.spec.lib_files
+  cmd << gem_minitest_logger.spec.extra_rdoc_files
+  cmd << gem_minitest_logger.spec.rdoc_options
+  `#{cmd.join(' ')}`
+end
+
+#~ desc "Gem minitest-logger"
+#~ task :default => :check
+#~ task :default => :test
+#~ task :default => :gem
+#~ task :default => :install
+#~ task :default => :hanna
+#~ task :default => :rdoc_local
+#~ task :default => :links
+#~ task :default => :ftp_rdoc
+task :default => :push
+
+
+if $0 == __FILE__
+  app = Rake.application
+  app[:default].invoke
+end
+__END__

data/unittest/test_load_minitest-logger.rb

@@ -0,0 +1,14 @@
+#encoding: utf-8
+=begin rdoc
+Tests for minitest-logger
+=end
+gem 'minitest'
+require 'minitest/autorun'
+  
+$:.unshift('../lib')
+
+class Test_minitest_logger < MiniTest::Test
+  def test_load
+    assert_raises(LoadError){ require 'minitest-logger'}
+  end
+end

data/unittest/test_minitest-log4r.rb

@@ -0,0 +1,93 @@
+#encoding: utf-8
+=begin rdoc
+Tests for minitest-logger
+=end
+gem 'minitest'
+require 'minitest/autorun'
+  
+$:.unshift('../lib')
+#~ require 'log4r'
+#~ require 'minitest-logger'
+require 'minitest/log4r'
+
+class Test_minitest_log4r < MiniTest::Test
+      def setup
+        @log = Log4r::Logger.new('log')
+        @log.level = Log4r::INFO
+      end
+      
+      def test_silent
+        assert_silent{ @log.debug("hello world") }
+        assert_log(nil){ @log.debug("Hello World") }
+      end
+      def test_default_level
+        assert_log(" INFO log: Hello World\n"){ @log.info("Hello World") }
+        assert_log(" INFO log: Hello World\n WARN log: Hello World\n"){ 
+          @log.debug("Hello World")
+          @log.info("Hello World")
+          @log.warn("Hello World")
+        }
+      end
+      def test_warn
+        assert_log(" WARN log: Hello World\n", :level => Log4r::WARN){ 
+          @log.debug("Hello World") #catched by logger-level
+          @log.info("Hello World")    #catched by outputter-level
+          @log.warn("Hello World")
+        }
+      end
+      
+      def test_regexp
+        assert_log(/Hello World/){ @log.info("Hello World") }
+        assert_log(/Hello/){ @log.info("Hello World") }
+        assert_log(/World/){ @log.info("Hello World") }
+      end
+
+      def test_silent
+        assert_silent_log(){@log.debug("Hello World") }
+        assert_silent_log(:level => Log4r::ERROR){@log.warn("Hello World") }
+      end
+      def test_not_silent      
+        refute_silent_log(){ @log.info("Hello World") }
+        refute_silent_log(){ @log.warn("Hello World") }
+      end
+  
+end
+
+=begin
+Same with Specifications
+=end
+describe Log4r::Logger do
+  before do
+    @log = Log4r::Logger.new('log')
+    @log.level = Log4r::INFO
+  end
+
+  describe "When a debug-message is posted" do
+    it "must not be reported" do
+      lambda{ @log.debug('Hello World') }.must_log(nil)
+    end
+    it "must not be reported, even if we set the level to debug" do
+      lambda{ @log.debug('Hello World')}.must_log( nil, :level => Log4r::DEBUG)
+    end
+  end
+  
+  describe "When a info-message is posted" do
+    it "must be reported" do
+      lambda{ @log.info('Hello World')}.must_log( " INFO log: Hello World\n")
+    end
+    
+    it "must be not reported if we set the level to warn" do
+      lambda{ @log.info('Hello World')}.must_log( nil, :level => Log4r::WARN)
+    end
+    
+    it "the logger must not be silent" do
+      lambda{ @log.info('Hello World')}.must_not_silent_log()
+    end
+    
+    it "the logger must be silent on level warn" do
+      lambda{ @log.info('Hello World')}.must_silent_log(:level => Log4r::WARN)
+    end
+    
+  end
+
+end

data/unittest/test_minitest-logger.rb

@@ -0,0 +1,147 @@
+#encoding: utf-8
+=begin rdoc
+Tests for minitest-logger
+=end
+gem 'minitest'
+require 'minitest/autorun'
+  
+$:.unshift('../lib')
+#~ require 'logger'
+#~ require 'minitest-logger'
+require 'minitest/logger'
+
+class Test_minitest_logger_with_Logger_format < MiniTest::Test
+  
+      def setup
+        @log = Logger.new(IO.new(File::RDONLY,'w'))
+        @log.level = Logger::INFO
+        #Same format as Logger
+        @log.formatter = proc{ |serverity, time, progname, msg|
+            "%5s log: %s\n" % [serverity, msg]
+        }
+      end
+      
+      def test_silent
+        assert_silent{ @log.debug("hello world") }
+        assert_log(nil){ @log.debug("Hello World") }
+      end
+      def test_default_level
+        assert_log(" INFO log: Hello World\n"){ @log.info("Hello World") }
+        assert_log(" INFO log: Hello World\n WARN log: Hello World\n"){ 
+          @log.debug("Hello World")
+          @log.info("Hello World")
+          @log.warn("Hello World")
+        }
+      end
+      
+      def test_warn
+        assert_log(" WARN log: Hello World\n", :level => Logger::WARN){ 
+          @log.debug("Hello World") #catched by logger-level
+          @log.info("Hello World")
+          @log.warn("Hello World")
+        }
+      end
+      
+      def test_regexp
+        assert_log(/Hello World/){ @log.info("Hello World") }
+        assert_log(/Hello/){ @log.info("Hello World") }
+        assert_log(/World/){ @log.info("Hello World") }
+      end
+
+      def test_silent
+        assert_silent_log(){@log.debug("Hello World") }
+        assert_silent_log(:level => Logger::ERROR){@log.warn("Hello World") }
+      end
+      def test_not_silent      
+        refute_silent_log(){ @log.info("Hello World") }
+        refute_silent_log(){ @log.warn("Hello World") }
+      end
+  
+end
+
+=begin rdoc
+Logger-messages contain the actual date/time.
+
+So it may be a good idea to use regexp.
+=end
+class Test_minitest_logger < MiniTest::Test
+  
+      def setup
+        @log = Logger.new(IO.new(File::RDONLY,'w'))
+        @log.level = Logger::INFO
+      end
+      
+      def test_silent
+        assert_silent{ @log.debug("hello world") }
+        assert_log(nil){ @log.debug("Hello World") }
+      end
+      def test_default_level
+        assert_log(/I, \[.*\]  INFO -- : Hello World\n/){ @log.info("Hello World") }
+        assert_log(/I, \[.*\]  INFO -- : Hello World\nW, \[.*\]  WARN -- : Hello World\n/){ 
+          @log.debug("Hello World")
+          @log.info("Hello World")
+          @log.warn("Hello World")
+        }
+      end
+      
+      def test_warn
+        assert_log(/W, \[.*\]  WARN -- : Hello World\n/, :level => Logger::WARN){ 
+          @log.debug("Hello World") #catched by logger-level
+          @log.info("Hello World")
+          @log.warn("Hello World")
+        }
+      end
+
+      def test_with_date_and_pid
+        #This test may fail, if the processor is too slow.
+        assert_log(
+          Time.now.strftime("I, [%Y-%m-%dT%H:%M:%S.%6N ##{Process.pid}]  INFO -- : Hello World\n")
+          ){ 
+            @log.info("Hello World")
+          }
+      end
+      
+end
+
+
+=begin
+Same with Specifications
+=end
+describe Logger do
+  before do
+    @log = Logger.new(IO.new(File::RDONLY,'w'))
+    @log.level = Logger::INFO
+  end
+
+  describe "When a debug-message is posted" do
+    it "must not be reported" do
+      lambda{ @log.debug('Hello World') }.must_log(nil)
+    end
+    it "must not be reported, even if we set the level to debug" do
+      lambda{ @log.debug('Hello World')}.must_log( nil, :level => Logger::DEBUG)
+    end
+  end
+  
+  describe "When a info-message is posted" do
+    it "must be reported (If the processor is fast enough to get the same system time)" do
+      lambda{@log.info('Hello World')}.must_log(       
+        Time.now.strftime("I, [%Y-%m-%dT%H:%M:%S.%6N ##{Process.pid}]  INFO -- : Hello World\n"))
+      end
+      
+    it "must be not reported if we set the level to warn" do
+      lambda{ @log.info('Hello World')}.must_log( nil, :level => Logger::WARN)
+    end
+
+    it "the logger must not be silent" do
+      lambda{ @log.info('Hello World')}.must_not_silent_log()
+    end
+    
+    it "the logger must be silent on level warn" do
+      lambda{ @log.info('Hello World')}.must_silent_log(:level => Logger::WARN)
+    end
+
+
+  end
+
+end
+    

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: minitest-logger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Knut Lickert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Extend minitest by assert_log and enable minitest to test log messages.
+  Supports Logger and Log4r::Logger.
+email: knut@lickert.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- examples/example_assertions.rb
+- examples/example_specification.rb
+files:
+- examples/example_assertions.rb
+- examples/example_specification.rb
+- lib/minitest-logger.rb
+- lib/minitest/log4r.rb
+- lib/minitest/logger.rb
+- rakefile_minitest-logger.rb
+- unittest/test_load_minitest-logger.rb
+- unittest/test_minitest-log4r.rb
+- unittest/test_minitest-logger.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main lib/minitest-logger.rb"
+- '--title "Rdoc: Minitest-logger"'
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Log4r or Logger
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Extend minitest by assert_log
+test_files:
+- unittest/test_load_minitest-logger.rb
+- unittest/test_minitest-logger.rb
+- unittest/test_minitest-log4r.rb