Example #1
0
        public async Task TestFileLogger()
        {
            var xUnitLogger = new XUnitLogger(_testOutputHelper)
            {
                LogLevel = LogLevels.Verbose
            };

            LoggerMapper.RegisterLoggerFor <FileLogger>(xUnitLogger);

            // Define a pattern with seconds in it...
            const string filenamePattern = "{Processname}-{Timestamp:yyyyMMddHHmmss}{Extension}";

            using (var forwardingLogger = new ForwardingLogger {
                LogLevel = LogLevels.Verbose
            })
            {
                LoggerTestSupport.TestAllLogMethods(forwardingLogger);
                using (var fileLogger = new FileLogger())
                {
                    fileLogger.FilenamePattern        = filenamePattern;
                    fileLogger.ArchiveFilenamePattern = filenamePattern;
                    forwardingLogger.ReplacedWith(fileLogger);
                    // Force archiving, as the filename changes
                    await Task.Delay(2000);

                    LoggerTestSupport.TestAllLogMethods(fileLogger);
                }
            }
        }
Example #2
0
        /// <summary>
        ///     This will call all available methods on the ILogger
        /// </summary>
        public static void TestAllLogMethods(ILogger loggerUnderTest)
        {
            var logSource = LogSource.ForCustomSource(Guid.NewGuid().ToString());

            logSource.LogTo(loggerUnderTest);
            try
            {
                AssertLogLevels(logSource, loggerUnderTest);
                AssertWriteLines(logSource);
            }
            finally
            {
                LoggerMapper.DeRegisterLoggerFor(logSource, loggerUnderTest);
            }
        }
Example #3
0
        public void TestMapping()
        {
            var defaultLogger = LogSettings.RegisterDefaultLogger <StringWriterLogger>();

            var differentLogSource = LogSource.ForCustomSource("Test");
            var logger             = new StringWriterLogger();

            LoggerMapper.RegisterLoggerFor("Test", logger);

            const string visibleMessage    = "Should be visible";
            const string notVisibleMessage = "Should be NOT visible in logger, but arrive in the defaultLogger";

            differentLogSource.Info().WriteLine(visibleMessage);
            Log.Info().WriteLine(notVisibleMessage);
            Assert.Contains(visibleMessage, logger.Output);
            Assert.DoesNotContain(notVisibleMessage, logger.Output);
            Assert.Contains(notVisibleMessage, defaultLogger.Output);

            defaultLogger.Clear();
            LoggerMapper.DeRegisterLoggerFor("Test", logger);
            differentLogSource.Info().WriteLine(notVisibleMessage);
            Assert.DoesNotContain(notVisibleMessage, logger.Output);
            Assert.Contains(notVisibleMessage, defaultLogger.Output);
        }
Example #4
0
 public void Cleanup()
 {
     LoggerMapper.DeRegisterLoggerFor(_logSource, _loggerUnderTest);
 }