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>();
}
