public void LogFileCreatesAPhysicalCopyOfTheSourceFile()
{
using (TemporaryFile sourceFile = new TemporaryFile())
{
File.WriteAllText(sourceFile.FileName, "Source file content");
string copiedFilePath = null;
bool exists = false;
long sourceFileLength = sourceFile.GetSize();
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
LoggedFile file = filesContainer.LogFile(sourceFile.FileName, null);
copiedFilePath = file.FilePath;
exists = File.Exists(copiedFilePath);
Assert.IsTrue(exists);
Assert.AreEqual(sourceFileLength, file.FileSize);
}
exists = File.Exists(copiedFilePath);
Assert.IsFalse(exists);
exists = File.Exists(sourceFile.FileName);
Assert.IsTrue(exists);
}
}
public async Task AllowedContentTypeLogsTheResponseBodyAsAFile(string contentType)
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogResponseBody((HttpProperties httpProperties) => true);
ModuleInitializer.ReadInputStreamProvider = new EnableBufferingReadInputStreamProvider();
LoggedFile file = null;
string fileContent = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
file = arg.Files.FirstOrDefault();
fileContent = file == null ? null : File.ReadAllText(file.FilePath);
}));
string responseBody = $"ResponseBody {Guid.NewGuid()}";
var context = Helpers.MockHttpContext(responseContentType: contentType);
var middleware = Helpers.MockMiddleware(responseBody: responseBody);
await middleware.Invoke(context.Object);
Assert.IsNotNull(file);
Assert.AreEqual(responseBody, fileContent);
}
public void AllowedContentTypeLogsTheResponseBodyAsAFile(string contentType)
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogResponseBody((HttpProperties httpProperties) => true);
LoggedFile file = null;
string fileContent = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
file = arg.Files.FirstOrDefault();
fileContent = file == null ? null : File.ReadAllText(file.FilePath);
}));
string responseBody = $"ResponseBody {Guid.NewGuid()}";
var httpContext = Helpers.MockHttpContext(responseBody: responseBody);
httpContext.Setup(p => p.Response.Headers).Returns(Helpers.GenerateNameValueCollection(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Content-Type", contentType)
}));
KissLogHttpModule module = new KissLogHttpModule();
module.OnEndRequest(httpContext.Object);
Assert.IsNotNull(file);
Assert.AreEqual(responseBody, fileContent);
}
public void LogFileLogsErrorMessageWhenFileSizeIsTooLarge()
{
int maxFileSize = Convert.ToInt32(Constants.MaximumAllowedFileSizeInBytes);
byte[] contents = Enumerable.Range(0, maxFileSize + 1).Select(p => byte.MaxValue).ToArray();
var ex = new FileSizeTooLargeException(contents.Length, Constants.MaximumAllowedFileSizeInBytes);
Logger logger = new Logger();
using (TemporaryFile sourceFile = new TemporaryFile())
{
File.WriteAllBytes(sourceFile.FileName, contents);
using (FilesContainer filesContainer = new FilesContainer(logger))
{
LoggedFile file = filesContainer.LogFile(sourceFile.FileName, null);
}
}
LogMessage message = logger.DataContainer.LogMessages.FirstOrDefault();
Assert.IsNotNull(message);
Assert.AreEqual(LogLevel.Error, message.LogLevel);
Assert.IsTrue(message.Message.Contains(ex.Message));
}
/// <summary>
/// Finish building the file. Don't use this builder after that!
/// </summary>
/// <returns></returns>
public LoggedFile Close()
{
var ret = new LoggedFile(info.ID, log);
info = new FileLog.LoggedFileInfo();
log = null;
return(ret);
}
public void EmptyStringIsIgnored(string content)
{
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
LoggedFile loggedFile = filesContainer.LogAsFile(content, "File.txt");
Assert.IsNull(loggedFile);
}
}
public void EmptyByteArrayIsIgnored()
{
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
LoggedFile loggedFile = filesContainer.LogAsFile(new byte[] { }, "File.txt");
Assert.IsNull(loggedFile);
}
}
public void FileNameAlwaysHasValue(string fileName)
{
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
LoggedFile loggedFile = filesContainer.LogAsFile("Content", fileName);
Assert.IsNotNull(loggedFile.FileName);
}
}
public LoggedFile LogFile(string sourceFilePath, string fileName = null)
{
if (string.IsNullOrWhiteSpace(fileName))
{
fileName = Path.GetFileName(sourceFilePath);
}
fileName = NormalizeFileName(fileName);
FileInfo fi = new FileInfo(sourceFilePath);
if (!fi.Exists)
{
_logger.Error(new LogFileException(sourceFilePath, new FileNotFoundException(null, sourceFilePath)));
return(null);
}
if (fi.Length > Constants.MaximumAllowedFileSizeInBytes)
{
_logger.Error(new FileSizeTooLargeException(fi.Length, Constants.MaximumAllowedFileSizeInBytes));
return(null);
}
TemporaryFile temporaryFile = null;
try
{
temporaryFile = new TemporaryFile();
File.Delete(temporaryFile.FileName);
File.Copy(sourceFilePath, temporaryFile.FileName, true);
long length = temporaryFile.GetSize();
LoggedFile loggedFile = new LoggedFile(fileName, temporaryFile.FileName, length);
_temporaryFiles.Add(temporaryFile);
_loggedFiles.Add(loggedFile);
return(loggedFile);
}
catch (Exception ex)
{
if (temporaryFile != null)
{
temporaryFile.Dispose();
}
_logger.Error(new LogFileException(sourceFilePath, ex));
return(null);
}
}
public void LogByteArrayAsFileCreatesAPhysicalFile()
{
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
byte[] contents = Encoding.UTF8.GetBytes("Byte[] file content");
LoggedFile file = filesContainer.LogAsFile(contents, null);
FileInfo fi = new FileInfo(file.FilePath);
Assert.IsTrue(fi.Exists);
Assert.IsNotNull(file.FileName);
Assert.AreEqual(fi.Length, file.FileSize);
}
}
public void LogStringAsFileCreatesAPhysicalFile()
{
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
string contents = "String file content";
LoggedFile file = filesContainer.LogAsFile(contents, null);
FileInfo fi = new FileInfo(file.FilePath);
Assert.IsTrue(fi.Exists);
Assert.IsNotNull(file.FileName);
Assert.AreEqual(fi.Length, file.FileSize);
}
}
public void LogFileCopiesTheContentsOfTheSourceFile()
{
using (TemporaryFile sourceFile = new TemporaryFile())
{
string sourceContent = "Source file content";
File.WriteAllText(sourceFile.FileName, sourceContent);
using (FilesContainer filesContainer = new FilesContainer(new Logger()))
{
LoggedFile file = filesContainer.LogFile(sourceFile.FileName, null);
string content = File.ReadAllText(file.FilePath);
Assert.AreEqual(sourceContent, content);
}
}
}
public async Task NotAllowedContentTypeDoesNotLogTheResponseBody(string contentType)
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
LoggedFile file = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
file = arg.Files.FirstOrDefault();
}));
var context = Helpers.MockHttpContext(responseContentType: contentType);
var middleware = Helpers.MockMiddleware();
await middleware.Invoke(context.Object);
Assert.IsNull(file);
}
public void LogStringAsFileLogsErrorMessageWhenFileSizeIsTooLarge()
{
int maxFileSize = Convert.ToInt32(Constants.MaximumAllowedFileSizeInBytes);
string contents = string.Join(string.Empty, Enumerable.Range(0, maxFileSize + 1).Select(p => "0"));
var ex = new FileSizeTooLargeException(contents.Length, Constants.MaximumAllowedFileSizeInBytes);
Logger logger = new Logger();
using (FilesContainer filesContainer = new FilesContainer(logger))
{
LoggedFile file = filesContainer.LogAsFile(contents, null);
}
LogMessage message = logger.DataContainer.LogMessages.FirstOrDefault();
Assert.IsNotNull(message);
Assert.AreEqual(LogLevel.Error, message.LogLevel);
Assert.IsTrue(message.Message.Contains(ex.Message));
}
public LoggedFile LogAsFile(byte[] contents, string fileName = null)
{
if (contents == null || !contents.Any())
{
return(null);
}
fileName = NormalizeFileName(fileName);
long fileSize = contents.Length;
if (fileSize > Constants.MaximumAllowedFileSizeInBytes)
{
_logger.Error(new FileSizeTooLargeException(fileSize, Constants.MaximumAllowedFileSizeInBytes));
return(null);
}
TemporaryFile temporaryFile = null;
try
{
temporaryFile = new TemporaryFile();
File.WriteAllBytes(temporaryFile.FileName, contents);
LoggedFile loggedFile = new LoggedFile(fileName, temporaryFile.FileName, fileSize);
_temporaryFiles.Add(temporaryFile);
_loggedFiles.Add(loggedFile);
return(loggedFile);
}
catch (Exception ex)
{
if (temporaryFile != null)
{
temporaryFile.Dispose();
}
_logger.Error(new LogByteArrayAsFileException(contents, ex));
return(null);
}
}
public async Task EvaluatesOptionsShouldLogResponseBody()
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogResponseBody((HttpProperties args) => false);
LoggedFile file = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
file = arg.Files.FirstOrDefault();
}));
var context = Helpers.MockHttpContext();
var middleware = Helpers.MockMiddleware();
await middleware.Invoke(context.Object);
Assert.IsNull(file);
}
public void EvaluatesOptionsShouldLogResponseBody()
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
KissLogConfiguration.Options.ShouldLogResponseBody((HttpProperties args) => false);
LoggedFile file = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
file = arg.Files.FirstOrDefault();
}));
var httpContext = Helpers.MockHttpContext();
KissLogHttpModule module = new KissLogHttpModule();
module.OnEndRequest(httpContext.Object);
Assert.IsNull(file);
}
public void NotAllowedContentTypeDoesNotLogTheResponseBody(string contentType)
{
KissLog.Tests.Common.CommonTestHelpers.ResetContext();
LoggedFile file = null;
KissLogConfiguration.Listeners.Add(new KissLog.Tests.Common.CustomLogListener(onFlush: (FlushLogArgs arg) =>
{
file = arg.Files.FirstOrDefault();
}));
var httpContext = Helpers.MockHttpContext();
httpContext.Setup(p => p.Response.Headers).Returns(Helpers.GenerateNameValueCollection(new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("Content-Type", contentType)
}));
KissLogHttpModule module = new KissLogHttpModule();
module.OnEndRequest(httpContext.Object);
Assert.IsNull(file);
}
public void LogFileLogsErrorMessageWhenFileWasNotFound()
{
string fileName = null;
using (TemporaryFile tempFile = new TemporaryFile())
{
fileName = tempFile.FileName;
}
var ex = new LogFileException(fileName, new FileNotFoundException(null, fileName));
Logger logger = new Logger();
using (FilesContainer filesContainer = new FilesContainer(logger))
{
LoggedFile file = filesContainer.LogFile(fileName);
}
LogMessage message = logger.DataContainer.LogMessages.FirstOrDefault();
Assert.IsNotNull(message);
Assert.AreEqual(LogLevel.Error, message.LogLevel);
Assert.IsTrue(message.Message.Contains(ex.Message));
}
public void NegativeLengthThrowsException(long length)
{
LoggedFile item = new LoggedFile("File", @"D:\my\file.txt", length);
}
public void NullFilePathThrowsException(string filePath)
{
LoggedFile item = new LoggedFile("File", filePath, 0);
}
public void NullFileNameThrowsException(string fileName)
{
LoggedFile item = new LoggedFile(fileName, @"D:\my\file.txt", 0);
}
