Пример #1
0
        public static void LogWrite___Should_create_LogItem___When_logging_real_object_subject_via_lambda_without_comment()
        {
            // Arrange
            var logWriter = BuildAndConfigureMemoryLogWriter();
            var subject   = new TestObjectWithToStringForItsLog();

            // Act
            Log.Write(() => subject);
            Thread.Sleep(TimeSpan.FromMilliseconds(200));

            // Assert
            var logItem       = logWriter.LoggedItems.Single(_ => _.Subject.Summary.Contains(subject.ToString()));
            var actualSubject = logItem.Subject.DeserializeSubject <TestObjectWithToStringForItsLog>();

            logItem.Subject.Summary.Should().Be(subject.ToString());
            actualSubject.ToString().Should().Be(subject.ToString());
            logItem.Kind.Should().Be(LogItemKind.Object);
            logItem.Comment.Should().BeNull();

            logItem.Context.Should().NotBeNull();
            logItem.Context.StackTrace.Should().BeNull();
            logItem.Context.Origin.Should().Be(LogItemOrigin.ItsLogEntryPosted.ToString());
            logItem.Context.CallingMethod.Should().NotBeNullOrWhiteSpace();
            logItem.Context.CallingType.Should().NotBeNull();
            logItem.Context.MachineName.Should().NotBeNullOrWhiteSpace();
            logItem.Context.ProcessFileVersion.Should().NotBeNullOrWhiteSpace();
            logItem.Context.ProcessName.Should().NotBeNullOrWhiteSpace();
            logItem.Context.TimestampUtc.Should().BeOnOrBefore(DateTime.UtcNow);

            logItem.Correlations.Should().BeEmpty();
        }
Пример #2
0
        public static void Log_Enter_Activity_Trace___Records_details_correctly___With_exception_and_comment()
        {
            // Arrange
            var logWriter = BuildAndConfigureMemoryLogWriter();

            var enterSubject             = new TestObjectWithToStringForItsLog();
            var stringTraceWithoutLambda = "some trace without a lambda" + A.Dummy <string>();
            var stringTraceWithLambda    = "some trace with a lambda" + A.Dummy <string>();
            var traceObjectWithLambda    = new DifferentTestObjectWithToStringForItsLog();
            var exceptionToThrow         = new InvalidOperationException("Oh no.");

            // Act
            using (var log = Log.Enter(() => enterSubject))
            {
                try
                {
                    throw exceptionToThrow;
                }
                catch (Exception exception)
                {
                    log.Trace(() => exception);
                }

                log.Trace(stringTraceWithoutLambda);
                log.Trace(() => stringTraceWithLambda);
                log.Trace(() => traceObjectWithLambda);
            }

            // Assert
            logWriter.LoggedItems.ToList().ForEach(_ => _.Correlations.Single(c => c is ElapsedCorrelation).Should().NotBeNull());
            logWriter.LoggedItems.ToList().ForEach(_ => _.Correlations.Single(c => c is SubjectCorrelation).Should().NotBeNull());
            logWriter.LoggedItems.Select(_ => _.Correlations.Single(c => c is ElapsedCorrelation).CorrelationId).Count().Should()
            .Be(logWriter.LoggedItems.Count);
            logWriter.LoggedItems.Select(_ => _.Correlations.Single(c => c is SubjectCorrelation).CorrelationId).Count().Should()
            .Be(logWriter.LoggedItems.Count);
            logWriter.LoggedItems.ToList().ForEach(
                _ => ((SubjectCorrelation)_.Correlations.Single(c => c is SubjectCorrelation)).Subject
                .DeserializeSubject <TestObjectWithToStringForItsLog>().Test.Should().Be(enterSubject.Test));

            var enterItem = logWriter.LoggedItems.Single(_ => _.Correlations.Any(c => c is OrderCorrelation oc && oc.Position == 0));

            enterItem.Subject.DeserializeSubject <string>().Should().Be(UsingBlockLogger.InitialItemOfUsingBlockSubject);
            var enterCorrelation = (ElapsedCorrelation)enterItem.Correlations.Single(_ => _ is ElapsedCorrelation);

            enterCorrelation.ElapsedTime.TotalMilliseconds.Should().Be(0);

            var middleItems = logWriter.LoggedItems.Where(
                _ => new[] { exceptionToThrow.Message, stringTraceWithLambda, stringTraceWithoutLambda, traceObjectWithLambda.ToString() }.Any(
                    a => _.Subject.Summary.EndsWith(a, StringComparison.CurrentCulture))).ToList();

            middleItems.ForEach(_ =>
            {
                _.Correlations.Any(c => c is OrderCorrelation oc && oc.Position == 1).Should().BeTrue();
                var middleCorrelation = (ElapsedCorrelation)_.Correlations.Single(s => s is ElapsedCorrelation);
                middleCorrelation.ElapsedTime.TotalMilliseconds.Should().BeGreaterThan(0);
            });

            var exitItem = logWriter.LoggedItems.Single(_ => _.Correlations.Any(c => c is OrderCorrelation oc && oc.Position == 2));

            exitItem.Subject.DeserializeSubject <string>().Should().Be(UsingBlockLogger.FinalItemOfUsingBlockSubject);
            var exitCorrelation = (ElapsedCorrelation)exitItem.Correlations.Single(_ => _ is ElapsedCorrelation);

            exitCorrelation.ElapsedTime.TotalMilliseconds.Should().BeGreaterThan(0);
        }