public void LogWithSingleLoggerThrowing() { var level = LevelToLog.Info; var exception = new LoggingException(); var subLogger = new Mock <ILogger>(); { subLogger.Setup(l => l.Level) .Returns(level); subLogger.Setup(l => l.Log(It.IsAny <LogMessage>())) .Throws(exception); subLogger.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= level); } var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); try { logger.Log(new LogMessage(LevelToLog.Debug, "a")); } catch (LoggingException e) { Assert.AreEqual(1, e.InnerExceptions.Count); Assert.AreSame(exception, e.InnerExceptions[0]); } }
public void LogWithSingleLogger() { var level = LevelToLog.Info; LogMessage message = null; var subLogger = new Mock <ILogger>(); { subLogger.Setup(l => l.Level) .Returns(level); subLogger.Setup(l => l.Log(It.IsAny <LogMessage>())) .Callback <LogMessage>(m => message = m); subLogger.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= level); } var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); var messageToLog = new LogMessage(LevelToLog.Debug, "a"); logger.Log(messageToLog); Assert.IsNull(message); messageToLog = new LogMessage(LevelToLog.Info, "a"); logger.Log(messageToLog); Assert.AreSame(messageToLog, message); }
public void LogWithNullMessage() { var logger1Level = LevelToLog.Info; LogMessage logger1Message = null; var subLogger1 = new Mock <ILogger>(); { subLogger1.Setup(l => l.Level) .Returns(logger1Level); subLogger1.Setup(l => l.Log(It.IsAny <LogMessage>())) .Callback <LogMessage>(m => logger1Message = m); subLogger1.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= logger1Level); } var logger2Level = LevelToLog.Info; LogMessage logger2Message = null; var subLogger2 = new Mock <ILogger>(); { subLogger2.Setup(l => l.Level) .Returns(logger2Level); subLogger2.Setup(l => l.Log(It.IsAny <LogMessage>())) .Callback <LogMessage>(m => logger2Message = m); subLogger2.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= logger2Level); } var logger = new DistributedLogger(new ILogger[] { subLogger1.Object, subLogger2.Object }); logger.Log(null); Assert.IsNull(logger1Message); Assert.IsNull(logger2Message); }
public void ChangeLevelWithSingleLogger() { var subLogger = new Mock <ILogger>(); subLogger.SetupAllProperties(); var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); logger.Level = LevelToLog.Info; Assert.AreEqual(subLogger.Object.Level, LevelToLog.Info); }
public void ShouldLogWithNullMessage() { var level = LevelToLog.Info; var subLogger = new Mock <ILogger>(); { subLogger.Setup(l => l.Level) .Returns(level); } var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); Assert.IsFalse(logger.ShouldLog(null)); }
public void ShouldLogWithMessageWithLevelSetToNone() { var level = LevelToLog.None; var subLogger = new Mock <ILogger>(); { subLogger.Setup(l => l.Level) .Returns(level); } var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); Assert.IsFalse(logger.ShouldLog(new LogMessage(LevelToLog.Debug, "a"))); }
public void LevelWithSingleLogger() { var level = LevelToLog.Debug; var subLogger = new Mock <ILogger>(); { subLogger.Setup(l => l.Level) .Returns(level); } var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); Assert.AreEqual(level, logger.Level); }
public void ShouldLogWithSingleLogger() { var level = LevelToLog.Info; var subLogger = new Mock <ILogger>(); { subLogger.Setup(l => l.Level) .Returns(level); } var logger = new DistributedLogger(new ILogger[] { subLogger.Object }); Assert.IsFalse(logger.ShouldLog(new LogMessage(LevelToLog.Debug, "a"))); Assert.IsTrue(logger.ShouldLog(new LogMessage(LevelToLog.Info, "b"))); }
public void LogWithMultipleLoggersAtDifferentLevels() { var logger1Level = LevelToLog.Debug; LogMessage logger1Message = null; var subLogger1 = new Mock <ILogger>(); { subLogger1.Setup(l => l.Level) .Returns(logger1Level); subLogger1.Setup(l => l.Log(It.IsAny <LogMessage>())) .Callback <LogMessage>(m => logger1Message = m); subLogger1.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= logger1Level); } var logger2Level = LevelToLog.Info; LogMessage logger2Message = null; var subLogger2 = new Mock <ILogger>(); { subLogger2.Setup(l => l.Level) .Returns(logger2Level); subLogger2.Setup(l => l.Log(It.IsAny <LogMessage>())) .Callback <LogMessage>(m => logger2Message = m); subLogger2.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= logger2Level); } var logger = new DistributedLogger(new ILogger[] { subLogger1.Object, subLogger2.Object }); var messageToLog = new LogMessage(LevelToLog.Trace, "a"); logger.Log(messageToLog); Assert.IsNull(logger1Message); Assert.IsNull(logger2Message); messageToLog = new LogMessage(LevelToLog.Debug, "b"); logger.Log(messageToLog); Assert.AreSame(messageToLog, logger1Message); Assert.IsNull(logger2Message); messageToLog = new LogMessage(LevelToLog.Info, "c"); logger.Log(messageToLog); Assert.AreSame(messageToLog, logger1Message); Assert.AreSame(messageToLog, logger2Message); }
public void LogWithMultipleLoggersWithOneThrowing() { var logger1Level = LevelToLog.Debug; var logger1Exception = new LoggingException(); var subLogger1 = new Mock <ILogger>(); { subLogger1.Setup(l => l.Level) .Returns(logger1Level); subLogger1.Setup(l => l.Log(It.IsAny <LogMessage>())) .Throws(logger1Exception); subLogger1.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= logger1Level); } var logger2Level = LevelToLog.Info; LogMessage logger2Message = null; var subLogger2 = new Mock <ILogger>(); { subLogger2.Setup(l => l.Level) .Returns(logger2Level); subLogger2.Setup(l => l.Log(It.IsAny <LogMessage>())) .Callback <LogMessage>(m => logger2Message = m); subLogger2.Setup(l => l.ShouldLog(It.IsAny <LogMessage>())) .Returns <LogMessage>(m => m.Level >= logger2Level); } var logger = new DistributedLogger(new ILogger[] { subLogger1.Object, subLogger2.Object }); var messageToLog = new LogMessage(LevelToLog.Info, "a"); try { logger.Log(messageToLog); } catch (LoggingException e) { Assert.AreEqual(1, e.InnerExceptions.Count); Assert.AreSame(logger1Exception, e.InnerExceptions[0]); } Assert.AreSame(messageToLog, logger2Message); }
public void LevelWithMultipleLoggersWithDifferentLevels() { var logger1Level = LevelToLog.Debug; var subLogger1 = new Mock <ILogger>(); { subLogger1.Setup(l => l.Level) .Returns(logger1Level); } var logger2Level = LevelToLog.Info; var subLogger2 = new Mock <ILogger>(); { subLogger2.Setup(l => l.Level) .Returns(logger2Level); } var logger = new DistributedLogger(new ILogger[] { subLogger1.Object, subLogger2.Object }); Assert.AreEqual(logger1Level, logger.Level); }
public void ShouldLogWithMultipleLoggersAtSameLevel() { var logger1Level = LevelToLog.Info; var subLogger1 = new Mock <ILogger>(); { subLogger1.Setup(l => l.Level) .Returns(logger1Level); } var logger2Level = LevelToLog.Info; var subLogger2 = new Mock <ILogger>(); { subLogger2.Setup(l => l.Level) .Returns(logger2Level); } var logger = new DistributedLogger(new ILogger[] { subLogger1.Object, subLogger2.Object }); Assert.IsFalse(logger.ShouldLog(new LogMessage(LevelToLog.Trace, "a"))); Assert.IsFalse(logger.ShouldLog(new LogMessage(LevelToLog.Debug, "b"))); Assert.IsTrue(logger.ShouldLog(new LogMessage(LevelToLog.Info, "c"))); }