Implement more tests for NLog and Log4Net to increase coverage (#42)

Author: Lyrex

src/Ninject.Extensions.Logging.Log4Net.Test/Log4netTests.cs

@@ -41,9 +41,46 @@ static Log4netTests()
             // Configure the default repository
             var root = ((Hierarchy)log4net.LogManager.GetRepository(Assembly.GetCallingAssembly())).Root;
             root.AddAppender(testAppender);
+            root.Level = Level.Trace;
             root.Repository.Configured = true;
         }
 
+        /// <summary>
+        /// Tests trace logging
+        /// </summary>
+        [Fact]
+        public void LogTrace()
+        {
+            this.TestLog(Level.Trace, typeof(CtorPropertyLoggerClass).GetMethod("LogTrace"));
+        }
+
+        /// <summary>
+        /// Tests trace logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogTraceWithArguments()
+        {
+            this.TestLogWithArguments(Level.Trace, typeof(CtorPropertyLoggerClass).GetMethod("LogTraceWithArguments"));
+        }
+
+        /// <summary>
+        /// Tests trace exception logging
+        /// </summary>
+        [Fact]
+        public void LogTraceException()
+        {
+            this.TestLogException(Level.Trace, typeof(CtorPropertyLoggerClass).GetMethod("LogTraceException"));
+        }
+
+        /// <summary>
+        /// Tests trace exception logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogTraceWithException()
+        {
+            this.TestLogWithException(Level.Trace, typeof(CtorPropertyLoggerClass).GetMethod("LogTraceWithException"));
+        }
+
         /// <summary>
         /// Tests info logging
         /// </summary>
@@ -54,7 +91,25 @@ public void LogInfo()
         }
 
         /// <summary>
-        /// Tests info logging with exception
+        /// Tests info logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogInfoWithArguments()
+        {
+            this.TestLogWithArguments(Level.Info, typeof(CtorPropertyLoggerClass).GetMethod("LogInfoWithArguments"));
+        }
+
+        /// <summary>
+        /// Tests info exception logging
+        /// </summary>
+        [Fact]
+        public void LogInfoException()
+        {
+            this.TestLogException(Level.Info, typeof(CtorPropertyLoggerClass).GetMethod("LogInfoException"));
+        }
+
+        /// <summary>
+        /// Tests info exception logging with arguments
         /// </summary>
         [Fact]
         public void LogInfoWithException()
@@ -72,7 +127,25 @@ public void LogDebug()
         }
 
         /// <summary>
-        /// Tests debug logging with exception
+        /// Tests debug logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogDebugWithArguments()
+        {
+            this.TestLogWithArguments(Level.Debug, typeof(CtorPropertyLoggerClass).GetMethod("LogDebugWithArguments"));
+        }
+
+        /// <summary>
+        /// Tests debug exception logging
+        /// </summary>
+        [Fact]
+        public void LogDebugException()
+        {
+            this.TestLogException(Level.Debug, typeof(CtorPropertyLoggerClass).GetMethod("LogDebugException"));
+        }
+
+        /// <summary>
+        /// Tests debug exception logging with arguments
         /// </summary>
         [Fact]
         public void LogDebugWithException()
@@ -90,7 +163,25 @@ public void LogWarn()
         }
 
         /// <summary>
-        /// Tests warn logging with exception
+        /// Tests warn logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogWarnWithArguments()
+        {
+            this.TestLogWithArguments(Level.Warn, typeof(CtorPropertyLoggerClass).GetMethod("LogWarnWithArguments"));
+        }
+
+        /// <summary>
+        /// Tests warn exception logging
+        /// </summary>Exception
+        [Fact]
+        public void LogWarnException()
+        {
+            this.TestLogException(Level.Warn, typeof(CtorPropertyLoggerClass).GetMethod("LogWarnException"));
+        }
+
+        /// <summary>
+        /// Tests warn exception logging with arguments
         /// </summary>
         [Fact]
         public void LogWarnWithException()
@@ -108,7 +199,25 @@ public void LogError()
         }
 
         /// <summary>
-        /// Tests error logging with exception
+        /// Tests error logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogErrorWithArguments()
+        {
+            this.TestLogWithArguments(Level.Error, typeof(CtorPropertyLoggerClass).GetMethod("LogErrorWithArguments"));
+        }
+
+        /// <summary>
+        /// Tests error exception logging
+        /// </summary>
+        [Fact]
+        public void LogErrorException()
+        {
+            this.TestLogException(Level.Error, typeof(CtorPropertyLoggerClass).GetMethod("LogErrorException"));
+        }
+
+        /// <summary>
+        /// Tests error exception logging with arguments
         /// </summary>
         [Fact]
         public void LogErrorWithException()
@@ -126,7 +235,25 @@ public void LogFatal()
         }
 
         /// <summary>
-        /// Tests fatal logging with exception
+        /// Tests fatal logging with arguments
+        /// </summary>
+        [Fact]
+        public void LogFatalWithArguments()
+        {
+            this.TestLogWithArguments(Level.Fatal, typeof(CtorPropertyLoggerClass).GetMethod("LogFatalWithArguments"));
+        }
+
+        /// <summary>
+        /// Tests fatal exception logging
+        /// </summary>
+        [Fact]
+        public void LogFatalException()
+        {
+            this.TestLogException(Level.Fatal, typeof(CtorPropertyLoggerClass).GetMethod("LogFatalException"));
+        }
+
+        /// <summary>
+        /// Tests fatal exception logging with arguments
         /// </summary>
         [Fact]
         public void LogFatalWithException()
@@ -193,6 +320,29 @@ private void TestLog(Level level, MethodInfo methodInfo)
             {
                 var loggerClass = kernel.Get<CtorPropertyLoggerClass>();
 
+                methodInfo.Invoke(loggerClass, new object[] { "test message" });
+
+                var events = testAppender.GetEvents();
+                var lastLogEvent = testAppender.GetEvents()[testAppender.GetEvents().Length - 1];
+                lastLogEvent.Should().NotBeNull();
+                lastLogEvent.RenderedMessage.Should().Be("test message");
+                lastLogEvent.Level.Should().Be(level);
+                lastLogEvent.LoggerName.Should().Be(loggerClass.GetType().FullName);
+                lastLogEvent.ExceptionObject.Should().BeNull();
+            }
+        }
+
+        /// <summary>
+        /// Tests the logging without exception.
+        /// </summary>
+        /// <param name="level">The log level to be tested.</param>
+        /// <param name="methodInfo">The method info to be called to invoke the method to be tested.</param>
+        private void TestLogWithArguments(Level level, MethodInfo methodInfo)
+        {
+            using (var kernel = this.CreateKernel())
+            {
+                var loggerClass = kernel.Get<CtorPropertyLoggerClass>();
+
                 methodInfo.Invoke(loggerClass, new object[] { "message {0}", new object[] { 1 } });
 
                 var lastLogEvent = testAppender.GetEvents()[testAppender.GetEvents().Length - 1];
@@ -209,6 +359,29 @@ private void TestLog(Level level, MethodInfo methodInfo)
         /// </summary>
         /// <param name="logLevel">The log level to be tested.</param>
         /// <param name="methodInfo">The method info to be called to invoke the method to be tested.</param>
+        private void TestLogException(Level logLevel, MethodInfo methodInfo)
+        {
+            using (var kernel = this.CreateKernel())
+            {
+                var loggerClass = kernel.Get<CtorPropertyLoggerClass>();
+                var exception = new ArgumentException();
+
+                methodInfo.Invoke(loggerClass, new object[] { "exception message", exception });
+
+                var lastLogEvent = testAppender.GetEvents()[testAppender.GetEvents().Length - 1];
+                lastLogEvent.Should().NotBeNull();
+                lastLogEvent.RenderedMessage.Should().Be("exception message");
+                lastLogEvent.Level.Should().Be(logLevel);
+                lastLogEvent.LoggerName.Should().Be(loggerClass.GetType().FullName);
+                lastLogEvent.ExceptionObject.Should().BeSameAs(exception);
+            }
+        }
+
+        /// <summary>
+        /// Tests the logging with exception.
+        /// </summary>
+        /// <param name="level">The log level to be tested.</param>
+        /// <param name="methodInfo">The method info to be called to invoke the method to be tested.</param>
         private void TestLogWithException(Level level, MethodInfo methodInfo)
         {
             using (var kernel = this.CreateKernel())
@@ -225,7 +398,6 @@ private void TestLogWithException(Level level, MethodInfo methodInfo)
                 lastLogEvent.LoggerName.Should().Be(loggerClass.GetType().FullName);
                 lastLogEvent.ExceptionObject.Should().BeSameAs(exception);
             }
-
         }
     }