public void Should_be_able_to_log_message_with_formatparams(LogLevel logLevel, TraceEventType severity)
        {
            Sut.Log(logLevel, () => "m {0}", null, "replaced");

            Target.Logs[0].Message.Should().Be("m replaced");
            Target.Logs[0].Severity.Should().Be(severity);
        }
        public void Should_be_able_to_log_message(LogLevel logLevel, LogEventLevel logEventLevel)
        {
            _sut.Log(logLevel, () => "m");

            _logEvent.Level.ShouldBe(logEventLevel);
            _logEvent.RenderMessage().ShouldBe("m");
        }
        public void Should_be_able_to_log_message_with_param(LogLevel logLevel, LogEventLevel logEventLevel)
        {
            _sut.Log(logLevel, () => "m {0}", null, "param");

            _logEvent.Level.ShouldBe(logEventLevel);
            _logEvent.RenderMessage().ShouldBe("m \"param\"");
        }
        public void Should_be_able_to_log_message(LogLevel logLevel, TraceEventType severity)
        {
            Sut.Log(logLevel, () => "m");

            Target.Logs[0].Message.Should().Be("m");
            Target.Logs[0].Severity.Should().Be(severity);
        }
        public void Should_be_able_to_log_message_and_exception_with_formatparams(LogLevel logLevel, TraceEventType severity)
        {
            var exception = new Exception("e");

            Sut.Log(logLevel, () => "m {abc}", exception, "replaced");

            Target.Logs[0].Message.Should().Be("m replaced" + Environment.NewLine + exception);
            Target.Logs[0].Severity.Should().Be(severity);
        }
        public void Should_be_able_to_log_message_and_exception(LogLevel logLevel, TraceEventType severity)
        {
            var exception = new Exception("e");

            Sut.Log(logLevel, () => "m", exception);

            Target.Logs[0].Message.Should().Be("m" + Environment.NewLine + exception);
            Target.Logs[0].Severity.Should().Be(severity);
        }
        public void Should_be_able_to_log_message_and_exception(LogLevel logLevel, LogEventLevel logEventLevel)
        {
            var exception = new Exception("e");

            _sut.Log(logLevel, () => "m", exception);

            _logEvent.Level.ShouldBe(logEventLevel);
            _logEvent.RenderMessage().ShouldBe("m");
            _logEvent.Exception.ShouldBe(exception);
        }
        public void Should_be_able_to_log_message_and_exception(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m", new Exception("e"));

            _target.Logs[0].Should().Be(messagePrefix + "|||m|e");
        }
        public void Should_be_able_to_log_message(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m");

            _target.Logs[0].Should().Be(messagePrefix + "|||m|");
        }
        public void Should_be_able_to_log_message_with_format_parameters(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m {0}", null, "formatParam");

            _target.Logs[0].Should().Be(messagePrefix + "|||m formatParam|");
        }
Esempio n. 11
0
        public void Should_be_able_to_log_message_and_exception(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m", new Exception("e"));

            _target.Logs[0].ShouldBe(messagePrefix + "|||m|e");
        }
Esempio n. 12
0
        public void Should_be_able_to_log_message_and_exception_with_format_parameters(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m {abc}", new Exception("e"), new [] { "replaced" });

            _target.Logs[0].ShouldBe(messagePrefix + "|||m \"replaced\"|e");
        }
Esempio n. 13
0
        public void Should_be_able_to_log_message(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m");

            _target.Logs[0].ShouldBe(messagePrefix + "|||m|");
        }
Esempio n. 14
0
        public void Should_be_able_to_log_message_with_format_parameters(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m {0}", null, "formatParam");

            _target.Logs[0].ShouldBe(messagePrefix + "|||m formatParam|");
        }
        public void Should_be_able_to_log_message(LogLevel logLevel, LogEventLevel logEventLevel)
        {
            _sut.Log(logLevel, () => "m");

            _logEvent.Level.ShouldBe(logEventLevel);
            _logEvent.RenderMessage().ShouldBe("m");
        }
        public void Should_be_able_to_log_message_and_exception(LogLevel logLevel, LogEventLevel logEventLevel)
        {
            var exception = new Exception("e");
            _sut.Log(logLevel, () => "m", exception);

            _logEvent.Level.ShouldBe(logEventLevel);
            _logEvent.RenderMessage().ShouldBe("m");
            _logEvent.Exception.ShouldBe(exception);
        }
        public void Should_be_able_to_log_message_and_exception_with_format_parameters_modifiers(LogLevel logLevel, string messagePrefix)
        {
            _sut.Log(logLevel, () => "m {@abc}", new Exception("e"), new[] { "replaced" });

            _target.Logs[0].Should().Be(messagePrefix + "|||m replaced|e");
        }
        public void Should_be_able_to_log_message_with_param(LogLevel logLevel, LogEventLevel logEventLevel)
        {
            _sut.Log(logLevel, () => "m {0}", null, "param");

            _logEvent.Level.ShouldBe(logEventLevel);
            _logEvent.RenderMessage().ShouldBe("m \"param\"");
        }
        public void Should_enable_self_and_above_when_setup_with(LogEventLevel minimum, LogLevel[] expectedEnabledLevels)
        {
            AutoRollbackLoggerSetup(minimum,
                log =>
                {
                    foreach (var expectedEnabled in expectedEnabledLevels)
                    {
                        _checkIsEnabledFor[expectedEnabled](log)
                            .ShouldBeTrue();
                           // "loglevel: '{0}' should be enabled when minimum (serilog) level is '{1}'", expectedEnabled, minimum);
                    }

                    foreach (var expectedDisabled in _allLevels.Except(expectedEnabledLevels))
                    {
                        _checkIsEnabledFor[expectedDisabled](log)
                            .ShouldBeFalse();
                        //"loglevel '{0}' should be diabled when minimum (serilog) level is '{1}'", expectedDisabled, minimum);
                    }
                });
        }