public LoggingTests(IntegrationTestContext <Startup, AppDbContext> testContext) { _testContext = testContext; FakeLoggerFactory loggerFactory = null; testContext.ConfigureLogging(options => { loggerFactory = new FakeLoggerFactory(); options.ClearProviders(); options.AddProvider(loggerFactory); options.SetMinimumLevel(LogLevel.Trace); options.AddFilter((category, level) => level == LogLevel.Trace && (category == typeof(JsonApiReader).FullName || category == typeof(JsonApiWriter).FullName)); }); testContext.ConfigureServicesBeforeStartup(services => { if (loggerFactory != null) { services.AddSingleton(_ => loggerFactory); } }); }
public void RetryTest2() { FakeLoggerFactory loggerFac = new FakeLoggerFactory(); FakeDataOptions defaultOpts = new FakeDataOptions() { ConnectionString = "Host=localhost;", MaxRetries = 2, }; defaultOpts.ShouldRetryList.Add(typeof(Npgsql.NpgsqlException)); FakeDataCommand <int> command = new FakeDataCommand <int>("CommandForRetry", defaultOpts, loggerFac, (conn) => { throw new PostgresException(); // Emulating a Query error, for instance. }); Exception exception = null; try { command.Run(); } catch (Exception ex) { exception = ex; } Assert.Equal(command.ExecuteCount, 1); //Only one attempt, since no retry should be made to PostgresException Assert.True(exception != null); Assert.IsType <Npgsql.PostgresException>(exception); }
public async Task CheckAllFiles() { var workspace = await TestHelpers.CreateSimpleWorkspace(new Dictionary <string, string> { { "a.cs", "class C1 { int n = true; }" }, { "b.cs", "class C2 { int n = true; }" }, }); var fakeLoggerFactory = new FakeLoggerFactory(); var messages = new List <OmniSharp.Models.DiagnosticMessage>(); var emitter = new DiagnosticTestEmitter(messages); var forwarder = new DiagnosticEventForwarder(emitter); var service = new CSharpDiagnosticService(workspace, forwarder, fakeLoggerFactory); var controller = new DiagnosticsService(workspace, forwarder, service); var response = await controller.Handle(new OmniSharp.Models.DiagnosticsRequest()); await emitter.Emitted; Assert.Equal(1, messages.Count); var message = messages.First(); Assert.Equal(2, message.Results.Count()); var a = message.Results.First(x => x.FileName == "a.cs"); Assert.Equal(1, a.QuickFixes.Count()); Assert.Equal("a.cs", a.FileName); var b = message.Results.First(x => x.FileName == "b.cs"); Assert.Equal(1, b.QuickFixes.Count()); Assert.Equal("b.cs", b.FileName); }
public void Lazy_loading_is_logged_only_when_actually_loading() { var messages = new List <string>(); var loggerFactory = new FakeLoggerFactory(messages); using (var context = new WarningAsErrorContext(loggerFactory)) { context.Add(new WarningAsErrorEntity { Nav = new IncludedEntity() }); context.SaveChanges(); } using (var context = new WarningAsErrorContext(loggerFactory)) { var entity = context.WarningAsErrorEntities.OrderBy(e => e.Id).First(); messages.Clear(); Assert.NotNull(entity.Nav); Assert.Contains( CoreStrings.LogNavigationLazyLoading.GenerateMessage("Nav", "WarningAsErrorEntity"), messages); messages.Clear(); Assert.NotNull(entity.Nav); Assert.DoesNotContain( CoreStrings.LogNavigationLazyLoading.GenerateMessage("Nav", "WarningAsErrorEntity"), messages); } }
public void BatchInsertTest() { var dataOptions = new FakeDataOptions() { ConnectionString = "Host=localhost;" }; var loggerFactory = new FakeLoggerFactory(); FakeBatchCommand fakeCommand = new FakeBatchCommand(10, dataOptions, loggerFactory); //Add up to 30 entities //Execute should be execute 3 times. for (int i = 0; i < 30; i++) { fakeCommand.AddEntity(new Entity { Id = i }); } Assert.Equal(3, fakeCommand.ExecuteCount); fakeCommand.Run(); //In a real case, this would be called to dump remanescent data //Run for last execution (4 times) Assert.Equal(4, fakeCommand.ExecuteCount); }
public async Task CodeCheckSpecifiedFileOnly() { var workspace = await TestHelpers.CreateSimpleWorkspace(new Dictionary <string, string> { { "a.cs", "class C { int n = true; }" } }); var fakeLoggerFactory = new FakeLoggerFactory(); var messages = new List <OmniSharp.Models.DiagnosticMessage>(); var emitter = new DiagnosticTestEmitter(messages); var forwarder = new DiagnosticEventForwarder(emitter); forwarder.IsEnabled = true; var service = new CSharpDiagnosticService(workspace, forwarder, fakeLoggerFactory); service.QueueDiagnostics("a.cs"); await emitter.Emitted; Assert.Equal(1, messages.Count); var message = messages.First(); Assert.Equal(1, message.Results.Count()); var result = message.Results.First(); Assert.Equal(1, result.QuickFixes.Count()); Assert.Equal("a.cs", result.FileName); }
public LoggingTests(ExampleIntegrationTestContext <TestableStartup <AuditDbContext>, AuditDbContext> testContext) { _testContext = testContext; testContext.UseController <AuditEntriesController>(); FakeLoggerFactory loggerFactory = null; testContext.ConfigureLogging(options => { loggerFactory = new FakeLoggerFactory(); options.ClearProviders(); options.AddProvider(loggerFactory); options.SetMinimumLevel(LogLevel.Trace); options.AddFilter((_, __) => true); }); testContext.ConfigureServicesBeforeStartup(services => { if (loggerFactory != null) { services.AddSingleton(_ => loggerFactory); } }); }
public async Task LogsExceptionInPipelineStep() { using (var writer = new TestBulkWriter <PipelineTestsMyTestClass>()) { var items = Enumerable .Range(1, 1000) .Select(i => new PipelineTestsMyTestClass { Id = i, Name = "Bob" }) .ToAsyncEnumerable(); var loggerFactory = new FakeLoggerFactory(); var pipeline = EtlPipeline .StartWith(items) .Project <PipelineTestsMyTestClass>(i => throw new Exception("This is my exception")) .LogWith(loggerFactory) .WriteTo(writer); var pipelineTask = pipeline.ExecuteAsync(); await Assert.ThrowsAsync <Exception>(() => pipelineTask); var errorMessages = loggerFactory.LoggedMessages.Where(m => m.LogLevel == LogLevel.Error).ToList(); Assert.Single(errorMessages); Assert.Contains("Error", errorMessages[0].Message); Assert.Equal("This is my exception", errorMessages[0].Exception.Message); } }
public ExceptionHandlerTests(ExampleIntegrationTestContext <TestableStartup <ErrorDbContext>, ErrorDbContext> testContext) { _testContext = testContext; testContext.UseController <ThrowingArticlesController>(); testContext.UseController <ConsumerArticlesController>(); FakeLoggerFactory loggerFactory = null; testContext.ConfigureLogging(options => { loggerFactory = new FakeLoggerFactory(); options.ClearProviders(); options.AddProvider(loggerFactory); options.SetMinimumLevel(LogLevel.Warning); }); testContext.ConfigureServicesBeforeStartup(services => { if (loggerFactory != null) { services.AddSingleton(_ => loggerFactory); } }); testContext.ConfigureServicesAfterStartup(services => { services.AddResourceService <ConsumerArticleService>(); services.AddScoped <IExceptionHandler, AlternateExceptionHandler>(); }); }
public void Lazy_load_with_disposed_context_can_be_configured_to_log() { var messages = new List <string>(); var loggerFactory = new FakeLoggerFactory(messages); using (var context = new WarningAsErrorContext( loggerFactory, CoreEventId.LazyLoadOnDisposedContextWarning)) { context.Add(new WarningAsErrorEntity { Nav = new IncludedEntity() }); context.SaveChanges(); } WarningAsErrorEntity entity; using (var context = new WarningAsErrorContext( loggerFactory, CoreEventId.LazyLoadOnDisposedContextWarning)) { entity = context.WarningAsErrorEntities.OrderBy(e => e.Id).First(); } Assert.Null(entity.Nav); Assert.Contains( CoreStrings.LogLazyLoadOnDisposedContextWarning.GenerateMessage("Nav", "WarningAsErrorEntity"), messages); }
public void Throws_by_default_for_lazy_load_with_disposed_context() { var messages = new List <string>(); var loggerFactory = new FakeLoggerFactory(messages); using (var context = new WarningAsErrorContext(loggerFactory)) { context.Add(new WarningAsErrorEntity { Nav = new IncludedEntity() }); context.SaveChanges(); } WarningAsErrorEntity entity; using (var context = new WarningAsErrorContext(loggerFactory)) { entity = context.WarningAsErrorEntities.OrderBy(e => e.Id).First(); } Assert.Equal( CoreStrings.WarningAsErrorTemplate( CoreEventId.LazyLoadOnDisposedContextWarning.ToString(), CoreStrings.LogLazyLoadOnDisposedContextWarning.GenerateMessage("Nav", "WarningAsErrorEntity")), Assert.Throws <InvalidOperationException>( () => entity.Nav).Message); }
public async Task LogsStartAndFinishOfPipelineSteps() { using (var writer = new TestBulkWriter <PipelineTestsOtherTestClass>()) { var items = Enumerable.Range(1, 1000).Select(i => new PipelineTestsMyTestClass { Id = i, Name = "Bob" }); var loggerFactory = new FakeLoggerFactory(); var pipeline = EtlPipeline .StartWith(items) .LogWith(loggerFactory) .Aggregate(f => { Thread.Sleep(1); return(f.Max(c => c.Id)); }) .Pivot(i => { var result = new List <PipelineTestsMyTestClass>(); for (var j = 1; j <= i; j++) { result.Add(new PipelineTestsMyTestClass { Id = j, Name = $"Bob {j}" }); } return(result); }) .Project(i => { var nameParts = i.Name.Split(' '); return(new PipelineTestsOtherTestClass { Id = i.Id, FirstName = nameParts[0], LastName = nameParts[1] }); }) .TransformInPlace(i => { i.Id -= 1; i.FirstName = "Alice"; i.LastName = $"{i.Id}"; }) .WriteTo(writer); await pipeline.ExecuteAsync(); var totalStepsExpected = 6; Assert.True(2 * totalStepsExpected == loggerFactory.LoggedMessages.Count, string.Join("\r\n", loggerFactory.LoggedMessages.Select(m => m.Message))); //2 log messages for each step in the pipeline for (var i = 1; i <= totalStepsExpected; i++) { var messagesForStep = loggerFactory.LoggedMessages.Where(m => m.Message.Contains($"step {i} of {totalStepsExpected}")).ToList(); Assert.True(messagesForStep.Count == 2, $"Found {messagesForStep.Count} messages for step {i}"); Assert.Equal(1, messagesForStep.Count(m => m.Message.Contains("Starting"))); Assert.Equal(1, messagesForStep.Count(m => m.Message.Contains("Completing"))); } } }
public WarningAsErrorContext( FakeLoggerFactory sink = null, EventId?toLog = null, EventId?toThrow = null) { _sink = sink; _toLog = toLog; _toThrow = toThrow; }
public LoggingTests() { var factory = new FakeLoggerFactory(); _logger = factory.Logger; _bus = CqrsBus .UseAssemblyFor <FakeLogger>() .AddLogging(factory) .Build(); }
public async Task Response422IfUpdatingNotSettableAttribute() { // Arrange var builder = WebHost.CreateDefaultBuilder().UseStartup <TestStartup>(); var loggerFactory = new FakeLoggerFactory(); builder.ConfigureLogging(options => { options.AddProvider(loggerFactory); options.SetMinimumLevel(LogLevel.Trace); options.AddFilter((category, level) => level == LogLevel.Trace && (category == typeof(JsonApiReader).FullName || category == typeof(JsonApiWriter).FullName)); }); var server = new TestServer(builder); var client = server.CreateClient(); var todoItem = _todoItemFaker.Generate(); _context.TodoItems.Add(todoItem); await _context.SaveChangesAsync(); var serializer = TestFixture <TestStartup> .GetSerializer <TodoItem>(server.Host.Services, ti => new { ti.CalculatedValue }); var content = serializer.Serialize(todoItem); var request = PrepareRequest("PATCH", $"/api/v1/todoItems/{todoItem.Id}", content); // Act var response = await client.SendAsync(request); // Assert Assert.Equal(HttpStatusCode.UnprocessableEntity, response.StatusCode); var body = await response.Content.ReadAsStringAsync(); var document = JsonConvert.DeserializeObject <ErrorDocument>(body); Assert.Single(document.Errors); var error = document.Errors.Single(); Assert.Equal(HttpStatusCode.UnprocessableEntity, error.StatusCode); Assert.Equal("Failed to deserialize request body.", error.Title); Assert.StartsWith("Property 'TodoItem.CalculatedValue' is read-only. - Request body: <<", error.Detail); Assert.NotEmpty(loggerFactory.Logger.Messages); Assert.Contains(loggerFactory.Logger.Messages, x => x.Text.StartsWith("Received request at ") && x.Text.Contains("with body:")); Assert.Contains(loggerFactory.Logger.Messages, x => x.Text.StartsWith("Sending 422 response for request at ") && x.Text.Contains("Failed to deserialize request body.")); }
public DecorationTests() { FakeRetryFailuresEventHandler.TimesHandled = 0; var loggerFactory = new FakeLoggerFactory(); _logger = loggerFactory.Logger; _bus = CqrsBus.UseAssemblyFor <FakeLogger>() .AddLogging(loggerFactory) .AddRetry() .Build(); }
public void InvalidConnectionTest() { var mock = new Mock <DataCommandOptions>(); mock.Setup(opt => opt.CreateConnection()).Returns(() => null); //Setup some valid properties mock.Object.ConnectionString = "Host=localhost;"; FakeLoggerFactory loggerFac = new FakeLoggerFactory(); var command = new FakeDataCommand <int>("ACommand", mock.Object, loggerFac, (conn) => 0); Assert.Throws <InvalidOperationException>(() => command.Run()); }
protected UseCaseTests() { var loggerFactory = new FakeLoggerFactory(); var httpClientFactory = new FakeHttpClientFactory(); HttpClient = httpClientFactory.Client; var configurationFactory = new ConfigurationFactory(); Config = configurationFactory.Create(); _filesContainerMock = new Mock <CloudBlobContainer>(new Uri("https://something.com/files")); _filesContainerMock.Setup(s => s.GetBlockBlobReference(It.IsAny <string>())) .Returns(() => { var mock = CreateMockCloudBlockBlob("idk"); mock.Setup(s => s.ExistsAsync()).ReturnsAsync(false); return(mock.Object); }); var blobClientMock = new Mock <CloudBlobClient>(new Uri("https://something.com")); blobClientMock.Setup(s => s.GetContainerReference("files")).Returns(_filesContainerMock.Object); StorageAccount = new Mock <CloudStorageAccount>(new StorageCredentials("storageaccount", ""), false); StorageAccount.Setup(s => s.CreateCloudBlobClient()).Returns(blobClientMock.Object); var storageAccountFactory = new Mock <IStorageAccountFactory>(); storageAccountFactory.Setup(s => s.Get()).Returns(StorageAccount.Object); _provider = new ServiceCollection() .AddRealTimePresenter(Config) .RemoveAll <ILoggerFactory>() .AddSingleton <ILoggerFactory>(loggerFactory) .RemoveAll <IHttpClientFactory>() .AddSingleton <IHttpClientFactory>(httpClientFactory) .AddSingleton(httpClientFactory) .RemoveAll <IConfiguration>() .AddSingleton(Config) .RemoveAll <IStorageAccountFactory>() .AddSingleton(storageAccountFactory.Object) .BuildServiceProvider(); }
public void Adding_DbContext_Members_That_Do_Not_Implement_IIdentifiable_Logs_Warning() { // Arrange var loggerFactory = new FakeLoggerFactory(); var resourceGraphBuilder = new ResourceGraphBuilder(new JsonApiOptions(), loggerFactory); resourceGraphBuilder.AddResource(typeof(TestContext)); // Act resourceGraphBuilder.Build(); // Assert Assert.Single(loggerFactory.Logger.Messages); Assert.Equal(LogLevel.Warning, loggerFactory.Logger.Messages[0].LogLevel); Assert.Equal("Entity 'UnitTests.Internal.ResourceGraphBuilder_Tests+TestContext' does not implement 'IIdentifiable'.", loggerFactory.Logger.Messages[0].Text); }
public ConnectedProjectionsStreamStoreSubscriptionTests() { _fixture = new Fixture(); _streamStoreMock = new StreamStoreMock(); _commandBusMock = new Mock <IConnectedProjectionsCommandBus>(); var loggerFactory = new FakeLoggerFactory(); _loggerMock = loggerFactory.ResolveLoggerMock <ConnectedProjectionsStreamStoreSubscription>(); _sut = new ConnectedProjectionsStreamStoreSubscription( _streamStoreMock.Object, _commandBusMock.Object, loggerFactory); }
public ConnectedProjectionsCommandHandlerTests() { _fixture = new Fixture() .CustomizeConnectedProjectionIdentifiers() .CustomizeConnectedProjectionCommands(); var fakeLoggerFactory = new FakeLoggerFactory(); _handlerLoggerMock = fakeLoggerFactory.ResolveLoggerMock <ConnectedProjectionsCommandHandler>(); _subscriptionRunnerMock = new Mock <IConnectedProjectionsSubscriptionRunner>(); _catchUpRunnerMock = new Mock <IConnectedProjectionsCatchUpRunner>(); _commandBusMock = new Mock <IConnectedProjectionsCommandBus>(); _sut = new ConnectedProjectionsCommandHandler( _subscriptionRunnerMock.Object, _catchUpRunnerMock.Object, _commandBusMock.Object, fakeLoggerFactory); }
public async Task EnablesWhenEndPointIsHit() { var workspace = await TestHelpers.CreateSimpleWorkspace(new Dictionary <string, string> { { "a.cs", "class C1 { int n = true; }" }, { "b.cs", "class C2 { int n = true; }" }, }); var fakeLoggerFactory = new FakeLoggerFactory(); var messages = new List <OmniSharp.Models.DiagnosticMessage>(); var emitter = new DiagnosticTestEmitter(messages); var forwarder = new DiagnosticEventForwarder(emitter); var service = new CSharpDiagnosticService(workspace, forwarder, fakeLoggerFactory); var controller = new DiagnosticsService(workspace, forwarder, service); var response = await controller.Handle(new OmniSharp.Models.DiagnosticsRequest()); Assert.Equal(true, forwarder.IsEnabled); }
public void ConstructorTest() { DataCommandOptions defaultOpts = new FakeDataOptions(); FakeLoggerFactory loggerFac = new FakeLoggerFactory(); Assert.Throws <ArgumentNullException>(() => new FakeDataCommand <int>(null, null, null)); Assert.Throws <ArgumentNullException>(() => new FakeDataCommand <int>("", null, null)); Assert.Throws <ArgumentNullException>(() => new FakeDataCommand <int>(" ", null, null)); Assert.Throws <ArgumentNullException>(() => new FakeDataCommand <int>("WithAName", defaultOpts, null)); // Should check argument exceptions, because some properties in data options are empty // ConnectionString is a required option Assert.Throws <ArgumentException>(() => new FakeDataCommand <int>("WithAName", defaultOpts, loggerFac)); // Now, let's setup this as this should be defaultOpts.ConnectionString = "some connection string;"; // Creates a data command. No Exception should be thrown at this time. new FakeDataCommand <int>("WithAName", defaultOpts, loggerFac); }
public void ExecuteWithOpenConnectionTest() { var dataOptions = new FakeDataOptions() { ConnectionString = "Host=localhost;" }; var loggerFactory = new FakeLoggerFactory(); var mockCommand = new FakeDataCommand <int>("ACommand", dataOptions, loggerFactory, (conn) => 0); //Setup the mock command var ret = mockCommand.Run(); //Do the asserts Assert.True(dataOptions.CreatedConnection != null); Assert.True(dataOptions.CreatedConnection.OpenCount == 1); Assert.True(dataOptions.CreatedConnection.State == ConnectionState.Closed); Assert.True(mockCommand.LastExecuteState == ConnectionState.Open); Assert.True(ret == 0); }
public void When_using_custom_exception_handler_it_must_create_error_document_and_log() { // Arrange var loggerFactory = new FakeLoggerFactory(); var options = new JsonApiOptions { IncludeExceptionStackTraceInErrors = true }; var handler = new CustomExceptionHandler(loggerFactory, options); // Act var errorDocument = handler.HandleException(new NoPermissionException("YouTube")); // Assert Assert.Single(errorDocument.Errors); Assert.Equal("For support, email to: [email protected]?subject=YouTube", errorDocument.Errors[0].Meta.Data["support"]); Assert.NotEmpty((string[])errorDocument.Errors[0].Meta.Data["StackTrace"]); Assert.Single(loggerFactory.Logger.Messages); Assert.Equal(LogLevel.Warning, loggerFactory.Logger.Messages[0].LogLevel); Assert.Contains("Access is denied.", loggerFactory.Logger.Messages[0].Text); }
public void RetryTest1() { int tryOpenCount = 0; FakeDataOptions defaultOpts = new FakeDataOptions() { ConnectionString = "Host=localhost;", MaxRetries = 2, OnOpeningConnection = () => { tryOpenCount++; Task.Delay(1000); throw new Npgsql.NpgsqlException(); } }; defaultOpts.ShouldRetryList.Add(typeof(Npgsql.NpgsqlException)); FakeLoggerFactory loggerFac = new FakeLoggerFactory(); DataCommand <int> command = new FakeDataCommand <int>("CommandForRetry", defaultOpts, loggerFac); Exception exception = null; try { command.Run(); } catch (Exception ex) { exception = ex; } Assert.Equal(tryOpenCount, 3); //The first attempt + 2 retries Assert.True(exception != null); Assert.IsType <Npgsql.NpgsqlException>(exception); }
public void Low_level_services_can_be_replaced_after_being_added() { var serviceCollection = new ServiceCollection(); var loggerFactory = new FakeLoggerFactory(); serviceCollection .AddEntityFramework(); serviceCollection .AddInstance<ILoggerFactory>(loggerFactory); var provider = serviceCollection.BuildServiceProvider(); Assert.Same(loggerFactory, provider.GetRequiredService<ILoggerFactory>()); }
public void Required_low_level_services_are_not_added_if_already_present() { var serviceCollection = new ServiceCollection(); var loggerFactory = new FakeLoggerFactory(); serviceCollection .AddInstance<ILoggerFactory>(loggerFactory) .AddEntityFramework(); var provider = serviceCollection.BuildServiceProvider(); Assert.Same(loggerFactory, provider.GetRequiredService<ILoggerFactory>()); }
private Bot CreateBot() { fakeLoggerFactory = new FakeLoggerFactory(); return(new Bot(new CoyoteHandler(fakeLoggerFactory), new PostAnalyzer(null), new Blacklist(), fakeLoggerFactory)); }
protected override void When() { FakeLoggerFactory.InitializeOnce(); _createdLogger = LogFactory.Create("Given_a_app_configured_logger_factory.When_creating_a_logger"); }
protected override void When() { FakeLoggerFactory.InitializeOnce(); _createdLogger = LogFactory.Create <FakeLoggerFactory>(); }
public When_the_subscription_runner_processing_a_stream_event_throws_a_detected_stream_gap_exception() { var fixture = new Fixture(); _commandBusMock = new Mock <IConnectedProjectionsCommandBus>(); var streamMock = new Mock <IConnectedProjectionsStreamStoreSubscription>(); streamMock .SetupGet(stream => stream.StreamIsRunning) .Returns(true); var contextMock = new Mock <IConnectedProjectionContext <FakeProjectionContext> >(); contextMock .Setup(context => context.GetProjectionPosition(It.IsAny <ConnectedProjectionIdentifier>(), It.IsAny <CancellationToken>())) .ReturnsAsync((long?)null); var missingMessagesPositions = fixture.CreateMany <long>(2, 10).ToList(); _registeredProjections = new List <IConnectedProjection> { new FakeProjection( $"{MissingMessageProjectionIdentifier}-1", ThrowMissingMessageException(missingMessagesPositions), contextMock.Object), new FakeProjection( "do-nothing", (messages, strategy, name, ct) => Task.CompletedTask, contextMock.Object), new FakeProjection( $"{MissingMessageProjectionIdentifier}-2", ThrowMissingMessageException(missingMessagesPositions), contextMock.Object) }; var registeredProjectionsMock = new Mock <IRegisteredProjections>(); registeredProjectionsMock .Setup(projections => projections.GetProjection(It.IsAny <ConnectedProjectionIdentifier>())) .Returns((ConnectedProjectionIdentifier projectionId) => _registeredProjections.FirstOrDefault(projection => projection.Id.Equals(projectionId))); var loggerFactory = new FakeLoggerFactory(); _loggerMock = loggerFactory.ResolveLoggerMock <ConnectedProjectionsSubscriptionRunner>(); _gapStrategySettings = fixture.Create <StreamGapStrategyConfigurationSettings>(); var gapStrategyMock = new Mock <IStreamGapStrategy>(); gapStrategyMock .SetupGet(strategy => strategy.Settings) .Returns(_gapStrategySettings); _sut = new ConnectedProjectionsSubscriptionRunner( registeredProjectionsMock.Object, streamMock.Object, _commandBusMock.Object, gapStrategyMock.Object, loggerFactory); foreach (var projection in _registeredProjections) { _sut.HandleSubscriptionCommand(new Subscribe(projection.Id)).GetAwaiter(); } VerifySetup(); _sut.HandleSubscriptionCommand(new ProcessStreamEvent(fixture.Create <StreamMessage>(), fixture.Create <CancellationToken>())).GetAwaiter(); }