public void Constructor1SetsTimeoutToDefaultTimeoutWhenParameterIsNull()
        {
            var timeout         = TimeSpan.FromMilliseconds(1234);
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, timeout: null);

            fileLogProvider.Timeout.Should().Be(RollingFileLogProvider.DefaultTimeout);
        }
        public void Constructor1SetsTimeout()
        {
            var timeout         = TimeSpan.FromMilliseconds(1234);
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, timeout: timeout);

            fileLogProvider.Timeout.Should().Be(timeout);
        }
        public async Task WriteAsyncPrunesOldArchiveFiles()
        {
            const int maxFileSizeKilobytes = 50;

            var rollingFileLogProvider =
                new RollingFileLogProvider(
                    _logFilePath,
                    new JsonLogFormatter(),
                    maxFileSizeKilobytes: maxFileSizeKilobytes,
                    maxArchiveCount: 2);

            GetFileCount().Should().Be(0);

            await rollingFileLogProvider.WriteAsync(GetLogEntry());

            GetFileCount().Should().Be(1);

            await MakeOneArchiveFile(maxFileSizeKilobytes, rollingFileLogProvider);

            GetFileCount().Should().Be(2);

            await MakeOneArchiveFile(maxFileSizeKilobytes, rollingFileLogProvider);

            GetFileCount().Should().Be(3);

            await MakeOneArchiveFile(maxFileSizeKilobytes, rollingFileLogProvider);

            GetFileCount().Should().Be(3);

            await MakeOneArchiveFile(maxFileSizeKilobytes, rollingFileLogProvider);

            GetFileCount().Should().Be(3);
        }
        public async void PrunesOldArchiveFiles()
        {
            const int maxFileSizeKilobytes = 50;

            var logProvider =
                new RollingFileLogProvider(
                    _logFilePath,
                    maxFileSizeKilobytes,
                    2,
                    logFormatter: new SerializingLogFormatter(new XmlSerializerSerializer()));

            Assert.That(GetFileCount(), Is.EqualTo(0));

            await logProvider.WriteAsync(GetLogEntry());
            Assert.That(GetFileCount(), Is.EqualTo(1));

            await MakeOneArchiveFile(maxFileSizeKilobytes, logProvider);
            Assert.That(GetFileCount(), Is.EqualTo(2));

            await MakeOneArchiveFile(maxFileSizeKilobytes, logProvider);
            Assert.That(GetFileCount(), Is.EqualTo(3));

            await MakeOneArchiveFile(maxFileSizeKilobytes, logProvider);
            Assert.That(GetFileCount(), Is.EqualTo(3));

            await MakeOneArchiveFile(maxFileSizeKilobytes, logProvider);
            Assert.That(GetFileCount(), Is.EqualTo(3));
        }
        public void Constructor2SetsRolloverPeriod()
        {
            var logFormatter = new Mock <ILogFormatter>().Object;

            var fileLogProvider = new RollingFileLogProvider(_logFilePath, logFormatter, rolloverPeriod: RolloverPeriod.Hourly);

            fileLogProvider.RolloverPeriod.Should().Be(RolloverPeriod.Hourly);
        }
        public void Constructor2SetsMaxArchiveCount()
        {
            var logFormatter = new Mock <ILogFormatter>().Object;

            var fileLogProvider = new RollingFileLogProvider(_logFilePath, logFormatter, maxArchiveCount: 3);

            fileLogProvider.MaxArchiveCount.Should().Be(3);
        }
        public void Constructor2SetsMaxFileSizeKilobytes()
        {
            var logFormatter = new Mock <ILogFormatter>().Object;

            var fileLogProvider = new RollingFileLogProvider(_logFilePath, logFormatter, maxFileSizeKilobytes: 1);

            fileLogProvider.MaxFileSizeBytes.Should().Be(1024);
        }
        public void Constructor2SetsFormatter()
        {
            var logFormatter = new Mock <ILogFormatter>().Object;

            var fileLogProvider = new RollingFileLogProvider(_logFilePath, logFormatter);

            fileLogProvider.Formatter.Should().BeSameAs(logFormatter);
        }
        public void Constructor2SetsLevel()
        {
            var logFormatter = new Mock <ILogFormatter>().Object;

            var fileLogProvider = new RollingFileLogProvider(_logFilePath, logFormatter, level: LogLevel.Warn);

            fileLogProvider.Level.Should().Be(LogLevel.Warn);
        }
        public void Constructor1SetsFormatterToTemplateLogFormatter()
        {
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, "foo");

            fileLogProvider.Formatter.Should().BeOfType <TemplateLogFormatter>();
            var formatter = (TemplateLogFormatter)fileLogProvider.Formatter;

            formatter.Template.Should().Be("foo");
        }
        public void Constructor2SetsTimeout()
        {
            var logFormatter = new Mock <ILogFormatter>().Object;
            var timeout      = TimeSpan.FromMilliseconds(1234);

            var fileLogProvider = new RollingFileLogProvider(_logFilePath, logFormatter, timeout: timeout);

            fileLogProvider.Timeout.Should().Be(timeout);
        }
        public async Task WriteLineAsyncFormatsTheLogEntryAndWritesItToDisk()
        {
            var rollingFileLogProvider = new RollingFileLogProvider(_logFilePath, "{level}:{message}");

            var logEntry = new LogEntry("Hello, world!", LogLevel.Info);

            await rollingFileLogProvider.WriteAsync(logEntry);

            var output = await File.ReadAllTextAsync(_logFilePath);

            output.Should().Be($"Info:Hello, world!{Environment.NewLine}");
        }
        private static async Task MakeOneArchiveFile(int maxFileSizeKilobytes, RollingFileLogProvider rollingFileLogProvider)
        {
            var logEntry = GetLogEntry();

            // Write to the log file until it has exceeded the max file size.
            while (IsTooSmallForRollOver(maxFileSizeKilobytes))
            {
                await rollingFileLogProvider.WriteAsync(logEntry);
            }

            // This log entry should cause the existing log file to be archived, and a new one created.
            await rollingFileLogProvider.WriteAsync(logEntry);
        }
        public async void CausesTheLogFileToBeArchivedWhenItsSizeGetsTooBig()
        {
            const int maxFileSizeKilobytes = 50;

            var logProvider =
                new RollingFileLogProvider(
                    _logFilePath,
                    maxFileSizeKilobytes,
                    logFormatter: new SerializingLogFormatter(new XmlSerializerSerializer()));

            Assert.That(GetFileCount(), Is.EqualTo(0));

            await logProvider.WriteAsync(GetLogEntry());
            Assert.That(GetFileCount(), Is.EqualTo(1));

            await MakeOneArchiveFile(maxFileSizeKilobytes, logProvider);
            Assert.That(GetFileCount(), Is.EqualTo(2));
        }
        public async Task WriteAsyncCausesTheLogFileToBeArchivedWhenItsSizeGetsTooBig()
        {
            const int maxFileSizeKilobytes = 50;

            var rollingFileLogProvider =
                new RollingFileLogProvider(
                    _logFilePath,
                    new JsonLogFormatter(),
                    maxFileSizeKilobytes: maxFileSizeKilobytes);

            GetFileCount().Should().Be(0);

            await rollingFileLogProvider.WriteAsync(GetLogEntry());

            GetFileCount().Should().Be(1);

            await MakeOneArchiveFile(maxFileSizeKilobytes, rollingFileLogProvider);

            GetFileCount().Should().Be(2);
        }
        private static async Task MakeOneArchiveFile(int maxFileSizeKilobytes, RollingFileLogProvider logProvider)
        {
            var logEntry = GetLogEntry();

            // Write to the log file until it has exceeded the max file size.
            while (IsTooSmallForRollOver(maxFileSizeKilobytes))
            {
                await logProvider.WriteAsync(logEntry);
            }

            // This log entry should cause the existing log file to be archived, and a new one created.
            await logProvider.WriteAsync(logEntry);
        }
        public void Constructor1SetsRolloverPeriod()
        {
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, rolloverPeriod: RolloverPeriod.Hourly);

            fileLogProvider.RolloverPeriod.Should().Be(RolloverPeriod.Hourly);
        }
        public void Constructor1SetsMaxArchiveCount()
        {
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, maxArchiveCount: 3);

            fileLogProvider.MaxArchiveCount.Should().Be(3);
        }
        public void Constructor1SetsMaxFileSizeKilobytes()
        {
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, maxFileSizeKilobytes: 1);

            fileLogProvider.MaxFileSizeBytes.Should().Be(1024);
        }
        public void Constructor1SetsLevel()
        {
            var fileLogProvider = new RollingFileLogProvider(_logFilePath, level: LogLevel.Warn);

            fileLogProvider.Level.Should().Be(LogLevel.Warn);
        }