private Mock <ILog> SetupTraceForLoggerMock(Mock <ILog> mock, TargetLoggerMockLoggerSetupProperties props)
{
if (props.IsTraceEnabled)
{
if (props.TraceMessageExpectations != null)
{
string expectedMessage = props.TraceMessageExpectations.ExpectedMessage;
if (props.TraceMessageExpectations.ExpectedMessageArgs != null)
{
mock.Setup(m => m.InfoFormat(expectedMessage, props.TraceMessageExpectations.ExpectedMessageArgs))
.Verifiable();
}
else
{
mock.Setup(m => m.Info(expectedMessage))
.Verifiable();
}
}
else
{
mock.Setup(m => m.Info(It.IsAny <string>()))
.Verifiable();
mock.Setup(m => m.InfoFormat(It.IsAny <string>(), It.IsAny <string[]>()))
.Verifiable();
};
}
mock.SetupGet(m => m.IsInfoEnabled)
.Returns(props.IsTraceEnabled || props.IsInfoEnabled);
return(mock);
}
private void RunErrorLogMessageTests(bool withException)
{
LogMessageExpectations logExceptionExpectations = GenerateLogExceptionExpectations(withException,
withFormattedMessage: false);
TargetLoggerMockLoggerSetupProperties loggerSetupProps = TargetLoggerMockLoggerSetupProperties
.ErrorEnabledWithExpectations(logExceptionExpectations);
Mock <ILog> targetLoggerMock =
CreateLog4NetLoggerMock(loggerSetupProps);
Log4NetLogger stakhanoviseLogger =
new Log4NetLogger(targetLoggerMock.Object);
if (withException)
{
stakhanoviseLogger.Error(logExceptionExpectations.ExpectedMessage, logExceptionExpectations.ExpectedException);
}
else
{
stakhanoviseLogger.Error(logExceptionExpectations.ExpectedMessage);
}
targetLoggerMock.Verify();
}
private Mock <ILog> SetupFatalForLoggerMock(Mock <ILog> mock, TargetLoggerMockLoggerSetupProperties props)
{
if (props.IsFatalEnabled)
{
if (props.FatalMessageExpectations != null)
{
string expectedMessage = props.FatalMessageExpectations.ExpectedMessage;
if (props.FatalMessageExpectations.ExpectedException != null)
{
mock.Setup(m => m.Fatal(expectedMessage, props.FatalMessageExpectations.ExpectedException))
.Verifiable();
}
else
{
mock.Setup(m => m.Fatal(expectedMessage))
.Verifiable();
}
}
else
{
mock.Setup(m => m.Fatal(It.IsAny <string>()))
.Verifiable();
mock.Setup(m => m.Fatal(It.IsAny <string>(), It.IsAny <Exception>()))
.Verifiable();
}
}
mock.SetupGet(m => m.IsFatalEnabled)
.Returns(props.IsFatalEnabled);
return(mock);
}
private void RunWarnLogMessageTestsWithoutException(bool withFormattedMessage)
{
LogMessageExpectations logWarnExpectations = GenerateLogExceptionExpectations(withException: false,
withFormattedMessage: withFormattedMessage);
TargetLoggerMockLoggerSetupProperties loggerSetupProps = TargetLoggerMockLoggerSetupProperties
.WarnEnabledWithExpectations(logWarnExpectations);
Mock <ILog> targetLoggerMock =
CreateLog4NetLoggerMock(loggerSetupProps);
Log4NetLogger stakhanoviseLogger =
new Log4NetLogger(targetLoggerMock.Object);
if (withFormattedMessage)
{
stakhanoviseLogger.WarnFormat(logWarnExpectations.ExpectedMessage, logWarnExpectations.ExpectedMessageArgs);
}
else
{
stakhanoviseLogger.Warn(logWarnExpectations.ExpectedMessage);
}
targetLoggerMock.Verify();
}
private void RunTraceLogMessageTests(bool withFormattedMessage)
{
LogMessageExpectations logMessageExpectations =
GenerateLogMessageExpectations(withFormattedMessage);
TargetLoggerMockLoggerSetupProperties targetLoggerSetupProps = TargetLoggerMockLoggerSetupProperties
.TraceEnabledWithExpectations(logMessageExpectations);
Mock <ILog> targetLoggerMock =
CreateLog4NetLoggerMock(targetLoggerSetupProps);
Log4NetLogger stakhanoviseLogger =
new Log4NetLogger(targetLoggerMock.Object);
if (withFormattedMessage)
{
stakhanoviseLogger.TraceFormat(logMessageExpectations.ExpectedMessage, logMessageExpectations.ExpectedMessageArgs);
}
else
{
stakhanoviseLogger.Trace(logMessageExpectations.ExpectedMessage);
}
targetLoggerMock.Verify();
}
private void RunDebugLogEnabledCheckTests(bool withDebugLogEnabled)
{
TargetLoggerMockLoggerSetupProperties loggerSetupProps = withDebugLogEnabled
? TargetLoggerMockLoggerSetupProperties.DebugEnabledWithoutExpectations()
: TargetLoggerMockLoggerSetupProperties.DebugDisabled();
RunLogLevelEnabledCheckTests(loggerSetupProps,
StakhanoviseLogLevel.Debug,
withDebugLogEnabled);
}
private Mock <ILog> CreateLog4NetLoggerMock(TargetLoggerMockLoggerSetupProperties props)
{
Mock <ILog> mock = new Mock <ILog>(MockBehavior.Strict);
mock = SetupDebugForLoggerMock(mock, props);
mock = SetupErrorForLoggerMock(mock, props);
mock = SetupFatalForLoggerMock(mock, props);
mock = SetupInfoForLoggerMock(mock, props);
mock = SetupTraceForLoggerMock(mock, props);
mock = SetupWarnForLoggerMock(mock, props);
return(mock);
}
private void RunLogLevelEnabledCheckTests(TargetLoggerMockLoggerSetupProperties loggerSetupProps, StakhanoviseLogLevel logLevel, bool isLevelEnabled)
{
Mock <ILog> targetLoggerMock =
CreateLog4NetLoggerMock(loggerSetupProps);
Log4NetLogger stakhanoviseLogger =
new Log4NetLogger(targetLoggerMock.Object);
if (isLevelEnabled)
{
Assert.IsTrue(stakhanoviseLogger.IsEnabled(logLevel));
}
else
{
Assert.IsFalse(stakhanoviseLogger.IsEnabled(logLevel));
}
}
private Mock <ILog> SetupWarnForLoggerMock(Mock <ILog> mock, TargetLoggerMockLoggerSetupProperties props)
{
if (props.IsWarnEnabled)
{
if (props.WarnMessageExpectations != null)
{
string expectedMessage = props.WarnMessageExpectations.ExpectedMessage;
if (props.WarnMessageExpectations.ExpectedMessageArgs != null)
{
mock.Setup(m => m.WarnFormat(expectedMessage, props.WarnMessageExpectations.ExpectedMessageArgs))
.Verifiable();
}
else if (props.WarnMessageExpectations.ExpectedException != null)
{
mock.Setup(m => m.Warn(expectedMessage, props.WarnMessageExpectations.ExpectedException))
.Verifiable();
}
else
{
mock.Setup(m => m.Warn(expectedMessage))
.Verifiable();
}
}
else
{
mock.Setup(m => m.Warn(It.IsAny <string>()))
.Verifiable();
mock.Setup(m => m.Warn(It.IsAny <string>(), It.IsAny <Exception>()))
.Verifiable();
mock.Setup(m => m.WarnFormat(It.IsAny <string>(), It.IsAny <string[]>()))
.Verifiable();
};
}
mock.SetupGet(m => m.IsWarnEnabled)
.Returns(props.IsWarnEnabled);
return(mock);
}
