public void LogMessagesAreFilteredByInterceptorShouldLog()
{
CommonTestHelpers.ResetContext();
List <FlushLogArgs> args = new List <FlushLogArgs>();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => args.Add(arg))
{
Interceptor = new CustomLogListenerInterceptor
{
ShouldLogMessage = (LogMessage message) =>
{
return(message.LogLevel >= LogLevel.Warning);
}
}
});
Logger logger = new Logger();
logger.Trace("Trace");
logger.Debug("Debug");
logger.Info("Info");
logger.Warn("Warn");
logger.Error("Error");
logger.Critical("Critical");
NotifyFlush.Notify(new[] { logger });
Assert.AreEqual(3, args[0].MessagesGroups.ElementAt(0).Messages.Count());
}
public void LogListenerInterceptorShouldLogIsEvaluated()
{
CommonTestHelpers.ResetContext();
List <HttpRequest> httpRequestArgs = new List <HttpRequest>();
ILogListener listener = new CustomLogListener(onBeginRequest: (arg) => { httpRequestArgs.Add(arg); })
{
Interceptor = new CustomLogListenerInterceptor
{
ShouldLogBeginRequest = (HttpRequest httpRequest) =>
{
return(httpRequest.Url.LocalPath == "/App/Method1" || httpRequest.Url.LocalPath == "/App/Method3");
}
}
};
KissLogConfiguration.Listeners.Add(listener);
string[] urls = new[] { "/App/Method1", "/App/Method2", "/App/Method3", "/App/Method4" };
foreach (string url in urls)
{
HttpRequest httpRequest = new HttpRequest(new HttpRequest.CreateOptions
{
Url = UrlParser.GenerateUri(url),
HttpMethod = "GET"
});
NotifyBeginRequest.Notify(httpRequest);
}
Assert.AreEqual(2, httpRequestArgs.Count);
}
public void OptionsAreEvaluated()
{
CommonTestHelpers.ResetContext();
FlushLogArgs flushLogArgs = null;
KissLogConfiguration.Options.ShouldLogRequestHeader((OptionsArgs.LogListenerHeaderArgs args) => false);
KissLogConfiguration.Options.ShouldLogRequestCookie((OptionsArgs.LogListenerCookieArgs args) => false);
KissLogConfiguration.Options.ShouldLogFormData((OptionsArgs.LogListenerFormDataArgs args) => false);
KissLogConfiguration.Options.ShouldLogServerVariable((OptionsArgs.LogListenerServerVariableArgs args) => false);
KissLogConfiguration.Options.ShouldLogClaim((OptionsArgs.LogListenerClaimArgs args) => false);
KissLogConfiguration.Options.ShouldLogInputStream((OptionsArgs.LogListenerInputStreamArgs args) => false);
KissLogConfiguration.Options.ShouldLogResponseHeader((OptionsArgs.LogListenerHeaderArgs args) => false);
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => flushLogArgs = arg));
Logger logger = new Logger();
logger.DataContainer.SetHttpProperties(CommonTestHelpers.Factory.CreateHttpProperties());
NotifyFlush.Notify(new[] { logger });
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.Headers.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.Cookies.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.FormData.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.ServerVariables.Count());
Assert.AreEqual(0, flushLogArgs.HttpProperties.Request.Properties.Claims.Count());
Assert.IsNull(flushLogArgs.HttpProperties.Request.Properties.InputStream);
Assert.AreEqual(0, flushLogArgs.HttpProperties.Response.Properties.Headers.Count());
}
private void RunTestHttp(
string httpMethod, string origin,
string configXml, string json, string requestId, string userAgent, string userHostAddress,
DateTime serverSideTimeUtc, string url,
int expectedResponseCode, Dictionary <string, string> expectedResponseHeaders, List <LogEntry> expectedLogEntries)
{
// Arrange
LogResponse response = new LogResponse();
TestLogger logger = new TestLogger();
CommonTestHelpers.SetConfigCache(configXml, logger);
// Act
LoggerProcessor.ProcessLogRequest(
json,
new LogRequestBase(userAgent, userHostAddress, requestId, url, null, null, null),
serverSideTimeUtc,
httpMethod, origin, response);
// Assert
Assert.Equal(expectedResponseCode, response.StatusCode);
TestLogEntries(expectedLogEntries, logger.LogEntries);
TestResponseHeaders(expectedResponseHeaders, response.Headers);
}
public void NotifyShouldNotBeInvokedIfInterceptorShouldLogBeginRequestReturnsFalse()
{
CommonTestHelpers.ResetContext();
List <LogMessage> messageArgs = new List <LogMessage>();
ILogListener listener1 = new CustomLogListener(onMessage: (LogMessage message) => { messageArgs.Add(message); })
{
Interceptor = new CustomLogListenerInterceptor
{
ShouldLogBeginRequest = (HttpRequest httpRequest) => httpRequest.Url.LocalPath == "/App/Method2"
}
};
KissLogConfiguration.Listeners.Add(listener1);
ILogListener listener2 = new CustomLogListener(onMessage: (LogMessage message) => { messageArgs.Add(message); });
KissLogConfiguration.Listeners.Add(listener2);
Logger logger = new Logger(url: "/App/Method1");
logger.Trace("Message 1");
logger.Trace("Message 2");
logger = new Logger(url: "/App/Method2");
logger.Trace("Message 1");
logger.Trace("Message 2");
Assert.AreEqual(6, messageArgs.Count);
}
public void LogListenerInterceptorShouldLogIsEvaluated(int statusCode, bool expectedResult)
{
CommonTestHelpers.ResetContext();
List <FlushLogArgs> args = new List <FlushLogArgs>();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => args.Add(arg))
{
Interceptor = new CustomLogListenerInterceptor
{
ShouldLogFlush = (FlushLogArgs args) =>
{
return(args.HttpProperties.Response.StatusCode >= 400);
}
}
});
Logger logger = new Logger(url: $"/MyUrl/{statusCode}");
logger.DataContainer.HttpProperties.SetResponse(new HttpResponse(new HttpResponse.CreateOptions
{
StatusCode = statusCode
}));
NotifyFlush.Notify(new[] { logger });
Assert.AreEqual(expectedResult, args.Count == 1);
}
public void NotifyShouldNotBeInvokedIfInterceptorShouldLogBeginRequestReturnsFalse()
{
CommonTestHelpers.ResetContext();
List <FlushLogArgs> flushLogArgs = new List <FlushLogArgs>();
ILogListener listener1 = new CustomLogListener(onFlush: (FlushLogArgs args) => { flushLogArgs.Add(args); })
{
Interceptor = new CustomLogListenerInterceptor
{
ShouldLogBeginRequest = (HttpRequest httpRequest) => httpRequest.Url.LocalPath == "/App/Method2"
}
};
KissLogConfiguration.Listeners.Add(listener1);
ILogListener listener2 = new CustomLogListener(onFlush: (FlushLogArgs args) => { flushLogArgs.Add(args); });
KissLogConfiguration.Listeners.Add(listener2);
Logger logger = new Logger(url: "/App/Method1");
NotifyFlush.Notify(new[] { logger });
logger = new Logger(url: "/App/Method2");
NotifyFlush.Notify(new[] { logger });
logger = new Logger(url: "/App/Method3");
NotifyFlush.Notify(new[] { logger });
Assert.AreEqual(4, flushLogArgs.Count);
}
public void LogListenerInterceptorShouldLogIsEvaluated(LogLevel logLevel, bool expectedResult)
{
CommonTestHelpers.ResetContext();
List <LogMessage> messageArgs = new List <LogMessage>();
ILogListener listener = new CustomLogListener(onMessage: (LogMessage message) => { messageArgs.Add(message); })
{
Interceptor = new CustomLogListenerInterceptor
{
ShouldLogMessage = (LogMessage message) =>
{
return(message.LogLevel >= LogLevel.Warning);
}
}
};
KissLogConfiguration.Listeners.Add(listener);
LogMessage message = new LogMessage(new LogMessage.CreateOptions
{
CategoryName = Constants.DefaultLoggerCategoryName,
LogLevel = logLevel,
Message = "Message"
});
NotifyOnMessage.Notify(message);
Assert.AreEqual(expectedResult, messageArgs.Count == 1);
}
public void FactoryIsNotNull()
{
CommonTestHelpers.ResetContext();
ILoggerFactory factory = Logger.Factory;
Assert.IsNotNull(factory);
}
public void NotifyOnBeginRequestExceptionIsSilentlySwallowed()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onBeginRequest: (HttpRequest arg) => { throw new Exception(); }));
Logger logger = new Logger(url: "App/Method1");
}
public void NotifyMessageExceptionIsSilentlySwallowed()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onMessage: (LogMessage arg) => { throw new Exception(); }));
Logger logger = new Logger();
logger.Log(LogLevel.Trace, "Message");
}
private void RunTest(string configXml)
{
var sb = new StringBuilder();
CommonTestHelpers.SetConfigCache(configXml);
var configProcessor = new ConfigProcessor();
configProcessor.ProcessRootExec(sb, s => s, "23.89.450.1", "req", true);
}
public void IsLoggingUrl_NoUrl()
{
string configXml = @"
<jsnlog></jsnlog>
";
CommonTestHelpers.SetConfigCache(configXml, null);
Exception ex = Assert.Throws <ArgumentNullException>(() => LoggingUrlHelpers.IsLoggingUrl(null));
}
public void NegativeContentLengthThrowsException()
{
var options = new ResponseProperties.CreateOptions
{
Headers = CommonTestHelpers.GenerateList(2),
ContentLength = -1
};
ResponseProperties item = new ResponseProperties(options);
}
public void NotifyListenersExceptionIsSilentlySwallowed()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => { throw new Exception(); }));
Logger logger = new Logger();
Logger.NotifyListeners(logger);
}
public void ExceptionIsSilentlySwallowed()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.InternalLog = (message) =>
{
throw new Exception();
};
InternalLogger.LogException(new Exception());
}
public void IsLoggingUrl_NoUrlsConfigured()
{
string configXml = @"
<jsnlog></jsnlog>
";
CommonTestHelpers.SetConfigCache(configXml, null);
Assert.True(LoggingUrlHelpers.IsLoggingUrl("/jsnlog.logger"));
Assert.True(LoggingUrlHelpers.IsLoggingUrl("http://abc.com/jsnlog.logger"));
Assert.False(LoggingUrlHelpers.IsLoggingUrl("http://abc.com/jsnlog.css"));
}
public void NotifyOnBeginRequestContainsTheLoggerUrl()
{
CommonTestHelpers.ResetContext();
HttpRequest httpRequestArgs = null;
KissLogConfiguration.Listeners.Add(new CustomLogListener(onBeginRequest: (HttpRequest arg) => { httpRequestArgs = arg; }));
Logger logger = new Logger(url: "/App/Method1");
Assert.AreEqual(httpRequestArgs.Url.LocalPath, "/App/Method1");
}
private string ToJavaScript(string configXml)
{
var sb = new StringBuilder();
CommonTestHelpers.SetConfigCache(configXml);
var configProcessor = new ConfigProcessor();
configProcessor.ProcessRootExec(sb, s => s, "23.89.450.1", "req", false);
return(sb.ToString());
}
public void DeserializeAndFlattenWorks()
{
DirectoryInfo testDataDir = CommonTestHelpers.FindTestDataDirectory();
IJsonSerializer serializer = new SystemTextJsonSerializer();
foreach (var file in testDataDir.EnumerateFiles("*.json"))
{
string json = File.ReadAllText(file.FullName);
List <KeyValuePair <string, object> > result = serializer.DeserializeAndFlatten(json).ToList();
}
}
public void NullKeyValuesAreNotCopied(string keyName)
{
var options = new ResponseProperties.CreateOptions
{
Headers = CommonTestHelpers.GenerateList(keyName, 2),
ContentLength = 10000
};
ResponseProperties item = new ResponseProperties(options);
Assert.AreEqual(0, item.Headers.Count());
}
public void EvaluatesOptionsShouldLogClaim()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogClaim((OptionsArgs.LogListenerClaimArgs args) => false);
FlushLogArgs flushLogArgs = CommonTestHelpers.Factory.CreateFlushLogArgs();
FlushLogArgs result = NotifyFlush.CreateArgsForListener(flushLogArgs, new CustomLogListener());
Assert.AreEqual(0, result.HttpProperties.Request.Properties.Claims.Count());
Assert.AreNotEqual(0, flushLogArgs.HttpProperties.Request.Properties.Claims.Count());
}
public void EvaluatesOptionsShouldLogInputStream()
{
CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogInputStream((OptionsArgs.LogListenerInputStreamArgs args) => false);
FlushLogArgs flushLogArgs = CommonTestHelpers.Factory.CreateFlushLogArgs();
FlushLogArgs result = NotifyFlush.CreateArgsForListener(flushLogArgs, new CustomLogListener());
Assert.IsNull(result.HttpProperties.Request.Properties.InputStream);
Assert.IsNotNull(flushLogArgs.HttpProperties.Request.Properties.InputStream);
}
public void CreateOptionsConstructorUpdatesProperties()
{
var options = new ResponseProperties.CreateOptions
{
Headers = CommonTestHelpers.GenerateList(2),
ContentLength = 10000
};
ResponseProperties item = new ResponseProperties(options);
Assert.AreEqual(JsonSerializer.Serialize(options.Headers), JsonSerializer.Serialize(item.Headers));
Assert.AreEqual(options.ContentLength, item.ContentLength);
}
public void NotifyOnBeginRequestIsNotInvokedForLoggersWithoutUrl()
{
CommonTestHelpers.ResetContext();
List <HttpRequest> onBeginRequestArgs = new List <HttpRequest>();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onBeginRequest: (HttpRequest arg) => { onBeginRequestArgs.Add(arg); }));
Logger logger1 = new Logger();
Logger logger2 = new Logger();
Assert.AreEqual(0, onBeginRequestArgs.Count);
}
public void NotifyMessageIsInvoked()
{
CommonTestHelpers.ResetContext();
List <LogMessage> messageArgs = new List <LogMessage>();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onMessage: (LogMessage arg) => { messageArgs.Add(arg); }));
Logger logger = new Logger();
logger.Log(LogLevel.Trace, "Message");
Assert.AreEqual(1, messageArgs.Count);
}
public void HeadersAreCopied()
{
var value = CommonTestHelpers.GenerateList(5);
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetUrl(UrlParser.GenerateUri("/Home/Index"));
httpRequest.Setup(p => p.Method).Returns("GET");
httpRequest.Setup(p => p.Headers).Returns(new CustomHeaderCollection(value.ToStringValuesDictionary()));
var result = HttpRequestFactory.Create(httpRequest.Object);
Assert.AreEqual(JsonSerializer.Serialize(value), JsonSerializer.Serialize(result.Properties.Headers));
}
public void IsLoggingUrl_DefaultConfigured_NoAppenderUrlsConfigured()
{
string configXml = @"
<jsnlog defaultAjaxUrl=""/jsnlogger""></jsnlog>
";
CommonTestHelpers.SetConfigCache(configXml, null);
Assert.True(LoggingUrlHelpers.IsLoggingUrl("/jsnlogger"));
Assert.True(LoggingUrlHelpers.IsLoggingUrl("/abc/def/jsnlogger"));
Assert.False(LoggingUrlHelpers.IsLoggingUrl("/jsnlog.logger"));
Assert.False(LoggingUrlHelpers.IsLoggingUrl("http://abc.com/jsnlog.logger"));
Assert.False(LoggingUrlHelpers.IsLoggingUrl("http://abc.com/jsnlog.css"));
}
public void NotifyContinuesForOtherListenersWhenOneThrowsAnException()
{
CommonTestHelpers.ResetContext();
List <FlushLogArgs> flushArgs = new List <FlushLogArgs>();
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => { throw new Exception(); }));
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => { flushArgs.Add(arg); }));
KissLogConfiguration.Listeners.Add(new CustomLogListener(onFlush: (FlushLogArgs arg) => { flushArgs.Add(arg); }));
Logger logger = new Logger();
NotifyFlush.Notify(new[] { logger });
Assert.AreEqual(2, flushArgs.Count);
}
public void QueryStringIsCopied()
{
var value = CommonTestHelpers.GenerateList(5);
var qs = new FormUrlEncodedContent(value).ReadAsStringAsync().Result;
var dictionary = CommonTestHelpers.GenerateDictionary(value);
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetUrl(UrlParser.GenerateUri("/Home/Index?" + qs));
httpRequest.Setup(p => p.Method).Returns("GET");
var result = HttpRequestFactory.Create(httpRequest.Object);
Assert.AreEqual(JsonSerializer.Serialize(value), JsonSerializer.Serialize(result.Properties.QueryString));
}
