private TestLoggerFactory BuildNamedOptionsExpectedResult() { var services = new ServiceCollection(); IOptionFormatter[] formatters = Enumerable .Range(1, 3) .Select(i => TestOptionsFormatter.CreateNamed(i.ToString(), Options.Create(new TestOptions { IntField = i }))) .ToArray <IOptionFormatter>(); var expected = new TestLoggerFactory(); var optionsLogger = new TestOptionsLogger(expected.CreateLogger <TestOptionsLogger>(), services.BuildServiceProvider()); optionsLogger.LogOptions(formatters); return(expected); }
public async Task Invoke_NonGrpcWebContentType_NotProcessed() { // Arrange var testSink = new TestSink(); var testLoggerFactory = new TestLoggerFactory(testSink, true); var middleware = CreateMiddleware(logger: testLoggerFactory.CreateLogger <GrpcWebMiddleware>()); var httpContext = new DefaultHttpContext(); // Act await middleware.Invoke(httpContext); // Assert Assert.AreEqual(0, testSink.Writes.Count); Assert.IsNull(httpContext.Features.Get <IHttpResponseTrailersFeature>()); }
public void LogsListOfAuthorizationFilters() { // Arrange var authFilter = Mock.Of <IAuthorizationFilter>(); var asyncAuthFilter = Mock.Of <IAsyncAuthorizationFilter>(); var orderedAuthFilterMock = new Mock <IOrderedAuthorizeFilter>(); orderedAuthFilterMock.SetupGet(f => f.Order).Returns(-100); var orderedAuthFilter = orderedAuthFilterMock.Object; var actionFilter = Mock.Of <IActionFilter>(); var asyncActionFilter = Mock.Of <IAsyncActionFilter>(); var exceptionFilter = Mock.Of <IExceptionFilter>(); var asyncExceptionFilter = Mock.Of <IAsyncExceptionFilter>(); var resultFilter = Mock.Of <IResultFilter>(); var asyncResultFilter = Mock.Of <IAsyncResultFilter>(); var resourceFilter = Mock.Of <IResourceFilter>(); var asyncResourceFilter = Mock.Of <IAsyncResourceFilter>(); var filters = new IFilterMetadata[] { actionFilter, asyncActionFilter, authFilter, asyncAuthFilter, orderedAuthFilter, exceptionFilter, asyncExceptionFilter, resultFilter, asyncResultFilter, resourceFilter, asyncResourceFilter }; var testSink = new TestSink(); var loggerFactory = new TestLoggerFactory(testSink, enabled: true); var logger = loggerFactory.CreateLogger("test"); // Act logger.AuthorizationFiltersExecutionPlan(filters); // Assert Assert.Single(testSink.Writes); var write = testSink.Writes[0]; Assert.Equal( "Execution plan of authorization filters (in the following order): " + $"{authFilter.GetType()}, {asyncAuthFilter.GetType()}, {orderedAuthFilter.GetType()} (Order: -100)", write.State.ToString()); }
public void CreatesLoggerName_OnNestedGenericType_CreatesWithoutGenericTypeArgumentsInformation() { // Arrange var fullName = typeof(GenericClass <GenericClass <string> >).GetGenericTypeDefinition().FullName; var fullNameWithoutBacktick = fullName.Substring(0, fullName.IndexOf('`')); var testSink = new TestSink(); var factory = new TestLoggerFactory(testSink, enabled: true); // Act var logger = factory.CreateLogger <GenericClass <GenericClass <string> > >(); logger.LogInformation("test message"); // Assert Assert.Single(testSink.Writes); Assert.Equal(fullNameWithoutBacktick, testSink.Writes[0].LoggerName); }
public static void Main(string[] args) { _loggerFactory = new TestLoggerFactory(); _loggerFactory.SetLogLevel <RedisMessageBus>(LogLevel.Trace); _loggerFactory.MaxLogEntriesToStore = Console.WindowHeight - (OPTIONS_MENU_LINE_COUNT + SEPERATOR_LINE_COUNT) - 1; _logger = _loggerFactory.CreateLogger <Program>(); var muxer = ConnectionMultiplexer.Connect("localhost"); _queue = new RedisQueue <PingRequest>(new RedisQueueOptions <PingRequest> { ConnectionMultiplexer = muxer }); _messageBus = new RedisMessageBus(o => o.Subscriber(muxer.GetSubscriber()).LoggerFactory(_loggerFactory).MapMessageTypeToClassName <EchoMessage>()); MonitorKeyPress(); DrawLoop(); }
public TestsForInfiniteDeadManSwitchRunner(ITestOutputHelper testOutputHelper) { var logger = new LoggerConfiguration() .MinimumLevel.Verbose() .Enrich.FromLogContext() .Enrich.WithThreadId() .WriteTo.TestOutput(testOutputHelper, outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level:w5}] #{ThreadId,-3} {SourceContext} {Message}{NewLine}{Exception}") .CreateLogger(); _loggerFactory = LoggerFactory.Create(builder => { builder.AddSerilog(logger); }); var loggerFactory = new TestLoggerFactory(_loggerFactory); _logger = _loggerFactory.CreateLogger <TestsForInfiniteDeadManSwitchRunner>(); _sessionFactory = new CapturingDeadManSwitchSessionFactory(new DeadManSwitchSessionFactory(loggerFactory)); _runner = new InfiniteDeadManSwitchRunner(loggerFactory.CreateLogger <InfiniteDeadManSwitchRunner>(), _sessionFactory); }
public void DoSomethingLogsMessage() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink); var logger = loggerFactory.CreateLogger <Sample>(); var sample = new Sample(logger); // Act sample.DoSomething(); // Assert Assert.Equal(1, sink.Writes.Count); var log = sink.Writes.Single(); // Assert the message rendered by a default formatter Assert.Equal("The answer is 42", log.Message); }
public void CreateScope_InnerTransactionWasNotCompleted_DisposeThrowsException() { using var loggerFactory = new TestLoggerFactory(); var uut = new TransactionScopeFactory( loggerFactory.CreateLogger <TransactionScopeFactory>()); var outerTransaction = uut.CreateScope(); using (var innerTransaction = uut.CreateScope()) { } outerTransaction.Complete(); Should.Throw <TransactionAbortedException>(() => { outerTransaction.Dispose(); }); }
public void FailsWithSqlite() { // Arrange var logger = _loggerFactory.CreateLogger <WeatherForecastController>(); var connection = new SqliteConnection("DataSource=:memory:"); connection.Open(); using var command = connection.CreateCommand(); command.CommandText = "PRAGMA FOREIGN_KEYS=OFF"; command.ExecuteNonQuery(); var dbContextOptionsWithSqlite = new DbContextOptionsBuilder <BloggingContext>() .UseSqlite(connection) .UseLoggerFactory(_loggerFactory) .Options; var dbContextWithSqlite = new BloggingContext(dbContextOptionsWithSqlite); PrePopulateDatabase(dbContextWithSqlite); var controllerWithSqlite = new WeatherForecastController(logger, dbContextWithSqlite); // Act // Fails with 'The LINQ expression ... could not be translated' // because Sqlite can't perform greater than / less than comparisons on DateTimeOffsets (because it stores it as a string) controllerWithSqlite .Invoking(x => x.Get()) .Should() .ThrowExactly <System.InvalidOperationException>() .And.Message.Should().StartWith("The LINQ expression 'DbSet<Post>()"); //The LINQ expression 'DbSet<Post>() // .Where(p0 => EF.Property<Nullable<int>>(EntityShaperExpression: // EntityType: Blog // ValueBufferExpression: // ProjectionBindingExpression: EmptyProjectionMember // IsNullable: False // , "BlogId") != null && object.Equals( // objA: (object)EF.Property<Nullable<int>>(EntityShaperExpression: // EntityType: Blog // ValueBufferExpression: // ProjectionBindingExpression: EmptyProjectionMember // IsNullable: False // , ""BlogId""), // objB: (object)EF.Property<Nullable<int>>(p0, "BlogId"))) // .Where(p0 => p0.PublicationDateTime > DateTimeOffset.Now.AddDays(-5))' could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to 'AsEnumerable', 'AsAsyncEnumerable', 'ToList', or 'ToListAsync'. See https://go.microsoft.com/fwlink/?linkid=2101038 for more information. }
public void DoSomethingLogsUsingCorrectFormat() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink); var logger = loggerFactory.CreateLogger <Sample>(); var sample = new Sample(logger); // Act sample.DoSomething(); // Assert Assert.Equal(1, sink.Writes.Count); var log = sink.Writes.Single(); var state = Assert.IsAssignableFrom <IEnumerable <KeyValuePair <string, object> > >(log.State); // Assert the the log format template LogValuesAssert.Contains("{OriginalFormat}", "The answer is {number}", state); }
public void DoSomethingLogsCorrectParameter() { // Arrange var sink = new TestSink(); var loggerFactory = new TestLoggerFactory(sink); var logger = loggerFactory.CreateLogger <Sample>(); var sample = new Sample(logger); // Act sample.DoSomething(); // Assert Assert.Equal(1, sink.Writes.Count); var log = sink.Writes.Single(); var state = Assert.IsAssignableFrom <IEnumerable <KeyValuePair <string, object> > >(log.State); // Assert specific parameters in the log entry LogValuesAssert.Contains("number", 42, state); }
public void CreateScope_ResultHasBeenDisposed_CompleteThrowsException() { using var loggerFactory = new TestLoggerFactory(); var uut = new TransactionScopeFactory( loggerFactory.CreateLogger <TransactionScopeFactory>()); var result = uut.CreateScope(); #pragma warning disable IDISP017 // Prefer using. #pragma warning disable IDISP016 // Don't use disposed instance. result.Dispose(); #pragma warning restore IDISP016 // Don't use disposed instance. #pragma warning restore IDISP017 // Prefer using. Should.Throw <ObjectDisposedException>(() => { result.Complete(); }); }
public void Initialise() { var loggerFactory = new TestLoggerFactory(); var builder = new PipelineBuilder(loggerFactory); var httpClient = new HttpClient(); var dataUpdateService = new DataUpdateService( loggerFactory.CreateLogger <DataUpdateService>(), httpClient); _engine = new EmptyEngineBuilder(loggerFactory) .Build(); var shareUsage = new ShareUsageBuilder(loggerFactory, httpClient) .Build(); _pipeline = builder .AddFlowElement(_engine) .AddFlowElement(shareUsage) .Build(); }
public void LogsFilters_OnlyWhenLogger_IsEnabled() { // Arrange var authFilter = Mock.Of <IAuthorizationFilter>(); var asyncAuthFilter = Mock.Of <IAsyncAuthorizationFilter>(); var actionFilter = Mock.Of <IActionFilter>(); var asyncActionFilter = Mock.Of <IAsyncActionFilter>(); var exceptionFilter = Mock.Of <IExceptionFilter>(); var asyncExceptionFilter = Mock.Of <IAsyncExceptionFilter>(); var resultFilter = Mock.Of <IResultFilter>(); var asyncResultFilter = Mock.Of <IAsyncResultFilter>(); var resourceFilter = Mock.Of <IResourceFilter>(); var asyncResourceFilter = Mock.Of <IAsyncResourceFilter>(); var filters = new IFilterMetadata[] { actionFilter, asyncActionFilter, authFilter, asyncAuthFilter, exceptionFilter, asyncExceptionFilter, resultFilter, asyncResultFilter, resourceFilter, asyncResourceFilter }; var testSink = new TestSink(); var loggerFactory = new TestLoggerFactory(testSink, enabled: false); var logger = loggerFactory.CreateLogger("test"); // Act logger.AuthorizationFiltersExecutionPlan(filters); logger.ResourceFiltersExecutionPlan(filters); logger.ActionFiltersExecutionPlan(filters); logger.ExceptionFiltersExecutionPlan(filters); logger.ResultFiltersExecutionPlan(filters); // Assert Assert.Empty(testSink.Writes); }
public async Task Invoke_GrpcWebContentTypeAndNotEnabled_NotProcessed() { // Arrange var testSink = new TestSink(); var testLoggerFactory = new TestLoggerFactory(testSink, true); var middleware = CreateMiddleware(logger: testLoggerFactory.CreateLogger <GrpcWebMiddleware>()); var httpContext = new DefaultHttpContext(); httpContext.Request.Method = HttpMethods.Post; httpContext.Request.ContentType = GrpcWebProtocolConstants.GrpcWebContentType; // Act await middleware.Invoke(httpContext); // Assert Assert.IsNull(httpContext.Features.Get <IHttpResponseTrailersFeature>()); Assert.AreEqual(2, testSink.Writes.Count); var writes = testSink.Writes.ToList(); Assert.AreEqual("DetectedGrpcWebRequest", writes[0].EventId.Name); Assert.AreEqual("GrpcWebRequestNotProcessed", writes[1].EventId.Name); }
public void Logged_Exception_WO_Demystifier_Is_Not_Demystified() { var testSink = new TestSink(); var factory = new TestLoggerFactory(testSink, enabled: true); var logger = factory.CreateLogger("Test"); Exception thrownException = null; try { new SampleExceptionGenerator(); } catch (Exception ex) { logger.LogError(ex, "While trying to test"); thrownException = ex; } Assert.Single(testSink.Writes); var stacktrace = testSink.Writes[0].Exception.ToString(); Assert.Equal(thrownException.ToString(), stacktrace); }
public void TestConfiguration() { using (var writer = new StringWriter()) { ConnectLoggingActionToLogger(message => writer.Write(message)); var configuration = new ConfigurationBuilder() .AddJsonFile(GetAppSettingsPath("appsettings.json")) .Build(); var loggerOptions = new LambdaLoggerOptions(configuration); Assert.False(loggerOptions.IncludeCategory); Assert.False(loggerOptions.IncludeLogLevel); Assert.False(loggerOptions.IncludeNewline); var loggerfactory = new TestLoggerFactory() .AddLambdaLogger(loggerOptions); int count = 0; var defaultLogger = loggerfactory.CreateLogger("Default"); defaultLogger.LogTrace(SHOULD_NOT_APPEAR); defaultLogger.LogDebug(SHOULD_APPEAR + (count++)); defaultLogger.LogCritical(SHOULD_APPEAR + (count++)); defaultLogger = loggerfactory.CreateLogger(null); defaultLogger.LogTrace(SHOULD_NOT_APPEAR); defaultLogger.LogDebug(SHOULD_APPEAR + (count++)); defaultLogger.LogCritical(SHOULD_APPEAR + (count++)); // change settings int countAtChange = count; loggerOptions.IncludeCategory = true; loggerOptions.IncludeLogLevel = true; loggerOptions.IncludeNewline = true; var msLogger = loggerfactory.CreateLogger("Microsoft"); msLogger.LogTrace(SHOULD_NOT_APPEAR); msLogger.LogInformation(SHOULD_APPEAR + (count++)); msLogger.LogCritical(SHOULD_APPEAR + (count++)); var sdkLogger = loggerfactory.CreateLogger("AWSSDK"); sdkLogger.LogTrace(SHOULD_APPEAR + (count++)); sdkLogger.LogInformation(SHOULD_APPEAR + (count++)); sdkLogger.LogCritical(SHOULD_APPEAR + (count++)); // get text and verify var text = writer.ToString(); // check that there are no unexpected strings in the text Assert.False(text.Contains(SHOULD_NOT_APPEAR)); // check that all expected strings are in the text for (int i = 0; i < count; i++) { var expected = SHOULD_APPEAR + i; Assert.True(text.Contains(expected), $"Expected to find '{expected}' in '{text}'"); } // check extras that were added mid-way int numberOfExtraBits = count - countAtChange; // count levels var logLevelStrings = Enum.GetNames(typeof(LogLevel)).Select(ll => $"[{ll}").ToList(); Assert.Equal(numberOfExtraBits, CountMultipleOccurences(text, logLevelStrings)); // count categories var categoryStrings = new string[] { "Microsoft", "AWSSDK" }; Assert.Equal(numberOfExtraBits, CountMultipleOccurences(text, categoryStrings)); // count newlines Assert.Equal(numberOfExtraBits, CountOccurences(text, Environment.NewLine)); } }
public void TestWilcardConfiguration() { using (var writer = new StringWriter()) { ConnectLoggingActionToLogger(message => writer.Write(message)); var configuration = new ConfigurationBuilder() .AddJsonFile(GetAppSettingsPath("appsettings.wildcard.json")) .Build(); var loggerOptions = new LambdaLoggerOptions(configuration); Assert.False(loggerOptions.IncludeCategory); Assert.False(loggerOptions.IncludeLogLevel); Assert.False(loggerOptions.IncludeNewline); var loggerfactory = new TestLoggerFactory() .AddLambdaLogger(loggerOptions); int count = 0; // Should match: // "Foo.*": "Information" var foobarLogger = loggerfactory.CreateLogger("Foo.Bar"); foobarLogger.LogTrace(SHOULD_NOT_APPEAR); foobarLogger.LogDebug(SHOULD_NOT_APPEAR); foobarLogger.LogInformation(SHOULD_APPEAR + (count++)); foobarLogger.LogWarning(SHOULD_APPEAR + (count++)); foobarLogger.LogError(SHOULD_APPEAR + (count++)); foobarLogger.LogCritical(SHOULD_APPEAR + (count++)); // Should match: // "Foo.Bar.Baz": "Critical" var foobarbazLogger = loggerfactory.CreateLogger("Foo.Bar.Baz"); foobarbazLogger.LogTrace(SHOULD_NOT_APPEAR); foobarbazLogger.LogDebug(SHOULD_NOT_APPEAR); foobarbazLogger.LogInformation(SHOULD_NOT_APPEAR); foobarbazLogger.LogWarning(SHOULD_NOT_APPEAR); foobarbazLogger.LogError(SHOULD_NOT_APPEAR); foobarbazLogger.LogCritical(SHOULD_APPEAR + (count++)); // Should match: // "Foo.Bar.*": "Warning" var foobarbuzzLogger = loggerfactory.CreateLogger("Foo.Bar.Buzz"); foobarbuzzLogger.LogTrace(SHOULD_NOT_APPEAR); foobarbuzzLogger.LogDebug(SHOULD_NOT_APPEAR); foobarbuzzLogger.LogInformation(SHOULD_NOT_APPEAR); foobarbuzzLogger.LogWarning(SHOULD_APPEAR + (count++)); foobarbuzzLogger.LogError(SHOULD_APPEAR + (count++)); foobarbuzzLogger.LogCritical(SHOULD_APPEAR + (count++)); // Should match: // "*": "Error" var somethingLogger = loggerfactory.CreateLogger("something"); somethingLogger.LogTrace(SHOULD_NOT_APPEAR); somethingLogger.LogDebug(SHOULD_NOT_APPEAR); somethingLogger.LogInformation(SHOULD_NOT_APPEAR); somethingLogger.LogWarning(SHOULD_NOT_APPEAR); somethingLogger.LogError(SHOULD_APPEAR + (count++)); somethingLogger.LogCritical(SHOULD_APPEAR + (count++)); // get text and verify var text = writer.ToString(); // check that there are no unexpected strings in the text Assert.False(text.Contains(SHOULD_NOT_APPEAR)); // check that all expected strings are in the text for (int i = 0; i < count; i++) { var expected = SHOULD_APPEAR + i; Assert.True(text.Contains(expected), $"Expected to find '{expected}' in '{text}'"); } } }
public async Task MoveNext_TokenCancelledDuringMoveNext_CancelTask() { // Arrange var ms = new SyncPointMemoryStream(); var testSink = new TestSink(); var testLoggerFactory = new TestLoggerFactory(testSink, enabled: true); var httpContext = new DefaultHttpContext(); httpContext.Features.Set <IRequestBodyPipeFeature>(new TestRequestBodyPipeFeature(PipeReader.Create(ms))); var serverCallContext = HttpContextServerCallContextHelper.CreateServerCallContext(httpContext, logger: testLoggerFactory.CreateLogger("Test")); var reader = new HttpContextStreamReader <HelloReply>(serverCallContext, MessageHelpers.ServiceMethod.ResponseMarshaller.ContextualDeserializer); var cts = new CancellationTokenSource(); var nextTask = reader.MoveNext(cts.Token); Assert.IsFalse(nextTask.IsCompleted); Assert.IsFalse(nextTask.IsCanceled); cts.Cancel(); try { await nextTask; Assert.Fail(); } catch (TaskCanceledException) { } Assert.IsTrue(nextTask.IsCompleted); Assert.IsTrue(nextTask.IsCanceled); Assert.AreEqual(1, testSink.Writes.Count); Assert.AreEqual("ReadingMessage", testSink.Writes.First().EventId.Name); }
public TestLogger(TestLoggerFactory factory) { _logger = factory.CreateLogger <T>(); }
public ILogger CreateLogger(string categoryName) { return(_loggerFactory.CreateLogger(categoryName)); }
public void TestLoggingExceptionsAndEvents() { using (var writer = new StringWriter()) { ConnectLoggingActionToLogger(message => writer.Write(message)); var configuration = new ConfigurationBuilder() .AddJsonFile(GetAppSettingsPath("appsettings.json")) .Build(); var loggerOptions = new LambdaLoggerOptions(configuration); var loggerfactory = new TestLoggerFactory() .AddLambdaLogger(loggerOptions); int countMessage = 0; int countEvent = 0; int countException = 0; var defaultLogger = loggerfactory.CreateLogger("Default"); defaultLogger.LogTrace(SHOULD_NOT_APPEAR_EVENT, SHOULD_NOT_APPEAR_EXCEPTION, SHOULD_NOT_APPEAR); defaultLogger.LogDebug(SHOULD_NOT_APPEAR_EVENT, SHOULD_APPEAR + (countMessage++)); defaultLogger.LogCritical(SHOULD_NOT_APPEAR_EVENT, SHOULD_APPEAR + (countMessage++)); defaultLogger = loggerfactory.CreateLogger(null); defaultLogger.LogTrace(SHOULD_NOT_APPEAR_EVENT, SHOULD_NOT_APPEAR); defaultLogger.LogDebug(SHOULD_NOT_APPEAR_EVENT, SHOULD_APPEAR + (countMessage++)); defaultLogger.LogCritical(SHOULD_NOT_APPEAR_EVENT, SHOULD_APPEAR + (countMessage++)); // change settings loggerOptions.IncludeCategory = true; loggerOptions.IncludeLogLevel = true; loggerOptions.IncludeNewline = true; loggerOptions.IncludeException = true; loggerOptions.IncludeEventId = true; var msLogger = loggerfactory.CreateLogger("Microsoft"); msLogger.LogTrace(SHOULD_NOT_APPEAR_EVENT, SHOULD_NOT_APPEAR_EXCEPTION, SHOULD_NOT_APPEAR); msLogger.LogInformation(GET_SHOULD_APPEAR_EVENT(countEvent++), GET_SHOULD_APPEAR_EXCEPTION(countException++), SHOULD_APPEAR + (countMessage++)); msLogger.LogCritical(GET_SHOULD_APPEAR_EVENT(countEvent++), GET_SHOULD_APPEAR_EXCEPTION(countException++), SHOULD_APPEAR + (countMessage++)); var sdkLogger = loggerfactory.CreateLogger("AWSSDK"); sdkLogger.LogTrace(GET_SHOULD_APPEAR_EVENT(countEvent++), GET_SHOULD_APPEAR_EXCEPTION(countException++), SHOULD_APPEAR + (countMessage++)); sdkLogger.LogInformation(GET_SHOULD_APPEAR_EVENT(countEvent++), GET_SHOULD_APPEAR_EXCEPTION(countException++), SHOULD_APPEAR + (countMessage++)); sdkLogger.LogCritical(GET_SHOULD_APPEAR_EVENT(countEvent++), GET_SHOULD_APPEAR_EXCEPTION(countException++), SHOULD_APPEAR + (countMessage++)); // get text and verify var text = writer.ToString(); // check that there are no unexpected strings in the text Assert.DoesNotContain(SHOULD_NOT_APPEAR, text); Assert.DoesNotContain(SHOULD_NOT_APPEAR_EVENT.Id.ToString(), text); Assert.DoesNotContain(SHOULD_NOT_APPEAR_EVENT.Name, text); Assert.DoesNotContain(SHOULD_NOT_APPEAR_EXCEPTION.Message, text); // check that all expected strings are in the text for (int i = 0; i < countMessage; i++) { var expectedMessages = SHOULD_APPEAR + i; Assert.True(text.Contains(expectedMessages), $"Expected to find '{expectedMessages}' in '{text}'"); } for (int i = 0; i < countException; i++) { var expectedMessages = SHOULD_APPEAR_EXCEPTION + i; Assert.True(text.Contains(expectedMessages), $"Expected to find '{expectedMessages}' in '{text}'"); } for (int i = 0; i < countEvent; i++) { var expectedMessages = SHOULD_APPEAR_EVENT + i; Assert.True(text.Contains(expectedMessages), $"Expected to find '{expectedMessages}' in '{text}'"); } } }
public CodeLensTests(ITestOutputHelper testOutputHelper) { var factory = new TestLoggerFactory(testOutputHelper); _logger = factory.CreateLogger <CodeActionContextTests>(); }