public async Task A_consumer_is_being_tested() { var builder = new ContainerBuilder(); builder.RegisterType <MyConsumer>(); builder.RegisterGeneric(typeof(ValidatorFilter <>)); builder.RegisterType <AValidator>() .As <IValidator <A> >(); builder.RegisterType <ConsumerConfigurationObserver>() .SingleInstance(); _container = builder.Build(); _observer = _container.Resolve <ConsumerConfigurationObserver>(); _harness = new InMemoryTestHarness(); _harness.OnConfigureBus += ConfigureBus; _consumer = _harness.Consumer(new AutofacConsumerFactory <MyConsumer>(_container, "message")); await _harness.Start(); Console.WriteLine(_harness.Bus.GetProbeResult().ToJsonString()); }
public async Task Should_publish_fileinfo_submitted_event() { // Arrange (Given) var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <SubmitFileInfoConsumer>(); await harness.Start(); try { var fileId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitFileInfo>(new { FileId = fileId, InVar.Timestamp, FileName = "filename.file", Folder = "c:/folder/" }); // Assert (Then) Assert.True(harness.Published.Select <FileInfoSubmitted>().Any()); } finally { await harness.Stop(); } }
public async Task Should_respond_with_rejection_if_test_file() { // Arrange (Given) var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <SubmitFileInfoConsumer>(); await harness.Start(); try { var fileId = NewId.NextGuid(); var requestClient = await harness.ConnectRequestClient <SubmitFileInfo>(); // Act (When) var response = await requestClient.GetResponse <FileInfoSubmissionRejected>(new { FileId = fileId, InVar.Timestamp, FileName = "TEST.file", Folder = "c:/folder/" }); // Assert (Then) Assert.Equal <Guid>(response.Message.FileId, fileId); Assert.True(consumer.Consumed.Select <SubmitFileInfo>().Any()); Assert.True(harness.Sent.Select <FileInfoSubmissionRejected>().Any()); } finally { await harness.Stop(); } }
public async Task Should_create_a_state_instance() { var orderStateMachine = new OrderStateMachine(); var harness = new InMemoryTestHarness(); var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.Bus.Publish <OrderSubmitted>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "12345" }); Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True); var instanceId = await saga.Exists(orderId, x => x.Submitted); Assert.That(instanceId, Is.Not.Null); var instance = saga.Sagas.Contains(instanceId.Value); Assert.That(instance.CustomerNumber, Is.EqualTo("12345")); } finally { await harness.Stop(); } }
public async Task Should_consume_submit_fileinfo_commands() { // Arrange (Given) var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(5) }; var consumer = harness.Consumer <SubmitFileInfoConsumer>(); await harness.Start(); try { var fileId = NewId.NextGuid(); // Act (When) await harness.InputQueueSendEndpoint.Send <SubmitFileInfo>(new { FileId = fileId, InVar.Timestamp, FileName = "filename.file", Folder = "c:/folder/" }); // Assert (Then) Assert.True(consumer.Consumed.Select <SubmitFileInfo>().Any()); Assert.False(harness.Sent.Select <FileInfoSubmissionAccepted>().Any()); Assert.False(harness.Sent.Select <FileInfoSubmissionRejected>().Any()); } finally { await harness.Stop(); } }
public async Task Should_keep_em_separated() { var internalHarness = new InMemoryTestHarness("internal"); var externalHarness = new InMemoryTestHarness("external"); ConsumerTestHarness <RelayConsumer> internalConsumer = internalHarness.Consumer(() => new RelayConsumer(externalHarness.Bus)); ConsumerTestHarness <RelayConsumer> externalConsumer = externalHarness.Consumer(() => new RelayConsumer(internalHarness.Bus)); var realConsumer = internalHarness.Consumer <RealConsumer>(); await internalHarness.Start(); try { await externalHarness.Start(); try { await externalHarness.Bus.Publish(new A()); realConsumer.Consumed.Select <A>().Any().ShouldBeTrue(); } finally { await externalHarness.Stop(); } } finally { await internalHarness.Stop(); } }
public async Task Should_respond_to_status_checks() { var harness = new InMemoryTestHarness(); var orderStateMachine = new OrderStateMachine(); var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.Bus.Publish <OrderSubmitted>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = customerNumber }); Assert.That(saga.Created.Select(x => x.CorrelationId == orderId).Any(), Is.True); var instanceId = await saga.Exists(orderId, x => x.Submitted); Assert.That(instanceId, Is.Not.Null); var requestClient = await harness.ConnectRequestClient <CheckOrder>(); var response = await requestClient.GetResponse <OrderStatus>(new { OrderId = orderId }); Assert.That(response.Message.State, Is.EqualTo(orderStateMachine.Submitted.Name)); } finally { await harness.Stop(); } }
public async Task Should_consume_submit_order_command() { var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); // 메시지를 Publish 하고, Response가 필요없는 경우, 그냥 직접 InputQueue 에 메시지를 전송해볼 수 있다. // --> 그러면, 정상적인 경우? 라면 등록된 Consumer 가 메시지를 수신하겠지? await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = orderId, Timestamp = InVar.Timestamp, CustomerNumber = "12345", }); Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True); } finally { await harness.Stop(); } }
public async Task Should_Consume_AccountCheckCommand() { var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer <ApprovalsSubscriptionsHandler>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send(new AccountCheckCommand { Id = Guid.NewGuid().ToString(), ProfileId = Guid.NewGuid().ToString() }); // did the endpoint consume the message Assert.True(await harness.Consumed.Any <AccountCheckCommand>()); // did the actual consumer consume the message Assert.True(await consumerHarness.Consumed.Any <AccountCheckCommand>()); } finally { await harness.Stop(); } }
public async void InMemory() { var counter = new FaultCounter(); var harness = new InMemoryTestHarness(); try { harness.OnConfigureInMemoryBus += cfg => cfg.UseRetry(x => { x.Immediate(1); x.ConnectRetryObserver(new RetryObserver(counter)); }); harness.OnConfigureInMemoryReceiveEndpoint += cfg => harness.Handler <PingMessage>(cfg, ctx => throw new Exception()); await harness.Start(); var faultHandlerTask = harness.SubscribeHandler <Fault <PingMessage> >(); await harness.InputQueueSendEndpoint.Send(new PingMessage(), ctx => { ctx.ResponseAddress = harness.BusAddress; ctx.FaultAddress = harness.BusAddress; }); await faultHandlerTask; Assert.Equal(1, counter.Faults); } finally { await harness.Stop(); } }
public async Task A_consumer_is_being_tested() { _loggerMock = new Mock <ILogger <SearchRequestConsumer> >(); _providerProfileMock = new Mock <IOptions <ProviderProfileOptions> >(); _retryConfigurationMock = new Mock <IOptions <RetryConfiguration> >(); _personSearchValidatorMock = new Mock <IValidator <Person> >(); _personSearchValidatorMock.Setup(x => x.Validate(It.Is <Person>(person => !string.IsNullOrEmpty(person.FirstName)))) .Returns(new ValidationResult(Enumerable.Empty <ValidationFailure>())); _personSearchValidatorMock.Setup(x => x.Validate(It.Is <Person>(person => string.IsNullOrEmpty(person.FirstName)))) .Returns(new ValidationResult(new List <ValidationFailure>() { new ValidationFailure("firstName", "firstName is required.") })); _harness = new InMemoryTestHarness(); _sut = _harness.Consumer(() => new SearchRequestConsumer(_personSearchValidatorMock.Object, _providerProfileMock.Object, _retryConfigurationMock.Object, _loggerMock.Object)); await _harness.Start(); await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest() { SearchRequestId = validGuid, TimeStamp = DateTime.Now, Person = new Person() { FirstName = "firstName", LastName = "lastName", DateOfBirth = new DateTime(2001, 1, 1) }, SearchRequestKey = "SearchRequestKey" }); await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest() { SearchRequestId = validGuid, TimeStamp = DateTime.Now, Person = new Person() { FirstName = "exception", LastName = "lastName", DateOfBirth = new DateTime(2001, 1, 1) }, SearchRequestKey = "SearchRequestKey" }); await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest() { SearchRequestId = inValidGuid, TimeStamp = DateTime.Now, Person = new Person() { FirstName = "", LastName = "lastName", DateOfBirth = new DateTime(2001, 1, 1) }, SearchRequestKey = "SearchRequestKey" }); }
public InMemoryTestFixture(InMemoryTestHarness harness) : base(harness) { InMemoryTestHarness = harness; InMemoryTestHarness.OnConfigureInMemoryBus += ConfigureInMemoryBus; InMemoryTestHarness.OnConfigureInMemoryReceiveEndpoint += ConfigureInMemoryReceiveEndpoint; }
public async Task Should_Consume_TransactionIsCheckedEvent() { var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer <TransactionsSubscriptionsHandler>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send(new TransactionIsCheckedEvent { ProfileId = Guid.NewGuid().ToString() }); // did the endpoint consume the message Assert.True(await harness.Consumed.Any <TransactionIsCheckedEvent>()); // did the actual consumer consume the message Assert.True(await consumerHarness.Consumed.Any <TransactionIsCheckedEvent>()); } finally { await harness.Stop(); } }
public async Task Should_respond_with_rejected_if_test() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(3) }; var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); // use this for request/response scenarios var requestClient = await harness.ConnectRequestClient <SubmitOrderCommand>(); var response = await requestClient.GetResponse <OrderSubmissionRejectedResponse>(new { OrderId = orderId, InVar.Timestamp, Customer = "TEST1234" }); response.Message.OrderId.IsSameOrEqualTo(orderId); consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue(); harness.Sent.Select <OrderSubmissionRejectedResponse>().Any().Should().BeTrue(); } finally { await harness.Stop(); } }
public async Task Should_respond_with_rejected_if_test() { var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); var requestClient = await harness.ConnectRequestClient <SubmitOrder>(); var response = await requestClient.GetResponse <OrderSubmissionRejected>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "TEST123" }); Assert.That(response.Message.OrderId, Is.EqualTo(orderId)); Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True); Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.True); } finally { await harness.Stop(); } }
public async Task Should_consume_submit_order_commands() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(5) }; var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "12345" }); Assert.That(consumer.Consumed.Select <SubmitOrder>().Any(), Is.True); Assert.That(harness.Sent.Select <OrderSubmissionAccepted>().Any(), Is.False); Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.False); } finally { await harness.Stop(); } }
public async Task Should_not_timeout() { var harness = new InMemoryTestHarness(); var machine = new TestSagaStateMachine(); StateMachineSagaTestHarness <TestSaga, TestSagaStateMachine> sagaHarness = harness.StateMachineSaga <TestSaga, TestSagaStateMachine>(machine); harness.TestTimeout = TimeSpan.FromSeconds(15); harness.OnConfigureBus += x => BusTestFixture.ConfigureBusDiagnostics(x); await harness.Start(); // Act try { IRequestClient <StartCommand> client = harness.CreateRequestClient <StartCommand>(); Response <StartCommandResponse> response = await client.GetResponse <StartCommandResponse>( new { CorrelationId = InVar.Id, }); // Assert // did the actual saga consume the message Assert.True(await sagaHarness.Consumed.Any <StartCommand>()); } finally { await harness.Stop(); } }
public async Task Should_publish_order_submitted_event() { var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "12345" }); Assert.That(await harness.Published.Any <OrderSubmitted>(), Is.True); } finally { await harness.Stop(); } }
public async Task Should_test_the_consumer() { var mockedReportService = new Mock <IReportService>(); var token = new CancellationTokenSource().Token; mockedReportService.Setup(rs => rs.Save(token)).Returns(Task.CompletedTask); var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <PersonConsumer>(() => new PersonConsumer(mockedReportService.Object), null); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send(new PersonDto() { Id = 1 }); // did the endpoint consume the message Assert.True(harness.Consumed.Select <PersonDto>().Any()); // did the actual consumer consume the message Assert.True(consumer.Consumed.Select <PersonDto>().Any()); } finally { await harness.Stop(); } }
public async Task Setup() { var collection = new ServiceCollection() .AddSingleton <ILoggerFactory>(_ => BusTestFixture.LoggerFactory) .AddSingleton(typeof(ILogger <>), typeof(Logger <>)) .AddMassTransitInMemoryTestHarness(cfg => { _testFixtureConfigurator.ConfigureFutureSagaRepository(cfg); cfg.SetKebabCaseEndpointNameFormatter(); ConfigureMassTransit(cfg); }) .AddGenericRequestClient(); _testFixtureConfigurator.ConfigureServices(collection); ConfigureServices(collection); Provider = collection.BuildServiceProvider(true); ConfigureLogging(); await _testFixtureConfigurator.OneTimeSetup(Provider); TestHarness = Provider.GetRequiredService <InMemoryTestHarness>(); TestHarness.TestTimeout = TimeSpan.FromSeconds(5); TestHarness.OnConfigureInMemoryBus += configurator => { ConfigureInMemoryBus(configurator); }; await TestHarness.Start(); }
public async Task Should_consume_submit_order_command() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(3) }; var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); // use this to send commands not request/response await harness.InputQueueSendEndpoint.Send <SubmitOrderCommand>(new { OrderId = orderId, InVar.Timestamp, Customer = "1234" }); consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue(); harness.Sent.Select <OrderSubmissionAcceptedResponse>().Any().Should().BeFalse(); harness.Sent.Select <OrderSubmissionRejectedResponse>().Any().Should().BeFalse(); } finally { await harness.Stop(); } }
public async Task SubmitOrderConsumer_Accepted() { var harness = new InMemoryTestHarness(); harness.Consumer <SubmitOrderConsumer>(); try { await harness.Start(); var orderId = NewId.NextGuid(); var requestClientSubmitOrder = await harness.ConnectRequestClient <ISubmitOrder>(); var(accepted, rejected) = await requestClientSubmitOrder.GetResponse <IOrderAccepted, IOrderRejected>(new { OrderId = orderId, Amount = 900 }); harness.Consumed.Select <ISubmitOrder>().Any().Should().Be.True(); accepted.IsCompletedSuccessfully.Should().Be.True(); rejected.IsCompletedSuccessfully.Should().Be.False(); harness.Published.Select <IOrderAcceptedEvent>().Any().Should().Be.True(); } finally { await harness.Stop(); } }
public async Task Should_respond_with_acceptance_if_ok() { var harness = new InMemoryTestHarness(); var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); // use this for request/response scenarios var requestClient = await harness.ConnectRequestClient <SubmitOrderCommand>(); var response = await requestClient.GetResponse <OrderSubmissionAcceptedResponse>(new { OrderId = orderId, InVar.Timestamp, Customer = "1234" }); response.Message.OrderId.IsSameOrEqualTo(orderId); consumer.Consumed.Select <SubmitOrderCommand>().Any().Should().BeTrue(); harness.Sent.Select <OrderSubmissionAcceptedResponse>().Any().Should().BeTrue(); // harness.Published.Select<OrderSubmittedEvent>().Any().Should().BeTrue(); } finally { await harness.Stop(); } }
public async Task A_consumer_is_being_tested() { _harness = new InMemoryTestHarness(); _fakeConsumerTestHarness = _harness.Consumer(() => new FakeFailureConsumer()); _personSearchObserver = new Mock <ILogger <PersonSearchObserver> >(); _providerProfileOptiosnMock = new Mock <IOptions <ProviderProfileOptions> >(); _providerProfileOptiosnMock.Setup(x => x.Value).Returns(new ProviderProfileOptions() { Name = "Adapter Tester" }); await _harness.Start(); _harness.Bus.ConnectConsumeMessageObserver(new PersonSearchObserver(_providerProfileOptiosnMock.Object, _personSearchObserver.Object)); await _harness.BusControl.Publish <PersonSearchOrdered>(new PersonSearchOrderedTest() { SearchRequestId = Guid.NewGuid(), TimeStamp = DateTime.Now, Person = new FakePerson() { FirstName = "", LastName = "lastName", DateOfBirth = new DateTime(2001, 1, 1) } }); }
public async Task Should_not_publish_order_submitted_event_when_rejected() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(3) }; var consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitOrderCommand>(new { OrderId = orderId, InVar.Timestamp, Customer = "TEST1234" }); harness.Published.Select <OrderSubmittedEvent>().Any().Should().BeFalse(); } finally { await harness.Stop(); } }
public async Task If_transformation_success_AssetReady_event_is_success() { // Arrange repositoryPackage.ArchiveRecordId = "113"; assetManager.Setup(e => e.ConvertPackage("113", AssetType.Gebrauchskopie, false, It.IsAny <RepositoryPackage>())) .ReturnsAsync(new PackageConversionResult { Valid = true, FileName = "113.zip" }); cacheHelper.Setup(e => e.GetFtpUrl(It.IsAny <IBus>(), It.IsAny <CacheRetentionCategory>(), It.IsAny <string>())) .ReturnsAsync("ftp://UsageCopyPublic:@someurl:9000/113"); cacheHelper.Setup(e => e.SaveToCache(It.IsAny <IBus>(), It.IsAny <CacheRetentionCategory>(), It.IsAny <string>())) .ReturnsAsync(true); var harness = new InMemoryTestHarness(); var consumer = harness.Consumer(() => new TransformPackageConsumer(assetManager.Object, cacheHelper.Object, harness.Bus)); harness.Consumer(() => assetReady.Object); await harness.Start(); try { // Act await harness.InputQueueSendEndpoint.Send <ITransformAsset>(new TransformAsset { AssetType = AssetType.Gebrauchskopie, RepositoryPackage = repositoryPackage, CallerId = "2223", RetentionCategory = CacheRetentionCategory.UsageCopyPublic }); // did the endpoint consume the message Assert.That(await harness.Consumed.Any <ITransformAsset>()); // did the actual consumer consume the message Assert.That(await consumer.Consumed.Any <ITransformAsset>()); // the consumer publish the event Assert.That(await harness.Published.Any <IAssetReady>()); // ensure that no faults were published by the consumer Assert.That(await harness.Published.Any <Fault <IAssetReady> >(), Is.False); // did the actual consumer consume the message Assert.That(await harness.Consumed.Any <IAssetReady>()); var message = harness.Consumed.Select <IAssetReady>().FirstOrDefault(); // Assert Assert.That(message != null); message.Context.Message.ArchiveRecordId.Should().Be("113"); message.Context.Message.CallerId = "2223"; message.Context.Message.Valid.Should().Be(true); } finally { await harness.Stop(); } }
public async Task A_consumer_is_being_tested() { _harness = new InMemoryTestHarness(); _batchConsumer = new TestBatchConsumer(_harness.GetTask <Batch <PingMessage> >()); _consumer = _harness.Consumer(() => _batchConsumer, c => c.Options <BatchOptions>(o => o.SetMessageLimit(2))); await _harness.Start(); }
public async Task SetUp() { _harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(5) }; _consumer = _harness.Consumer <SubmitOrderConsumer>(); await _harness.Start(); }
public async Task MassTransitInstrumentationConsumerAndHandlerTest() { var activityProcessor = new Mock <BaseProcessor <Activity> >(); using (Sdk.CreateTracerProviderBuilder() .AddProcessor(activityProcessor.Object) .AddMassTransitInstrumentation() .Build()) { var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer <TestConsumer>(); var handlerHarness = harness.Handler <TestMessage>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send <TestMessage>(new { Text = "Hello, world!", }); Assert.True(await harness.Consumed.SelectAsync <TestMessage>().Any()); Assert.True(await consumerHarness.Consumed.SelectAsync <TestMessage>().Any()); Assert.True(await handlerHarness.Consumed.SelectAsync().Any()); } finally { await harness.Stop(); } } Assert.Equal(10, activityProcessor.Invocations.Count); var sends = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Send); var receives = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Transport.Receive); var consumes = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Consume); var handles = this.GetActivitiesFromInvocationsByOperationName(activityProcessor.Invocations, OperationName.Consumer.Handle); foreach (var activity in sends) { Assert.Equal("SEND /input_queue", activity.DisplayName); } foreach (var activity in receives) { Assert.Equal("RECV /input_queue", activity.DisplayName); } foreach (var activity in consumes) { Assert.Equal("CONSUME OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests.TestConsumer", activity.DisplayName); } foreach (var activity in handles) { Assert.Equal("HANDLE TestMessage/OpenTelemetry.Contrib.Instrumentation.MassTransit.Tests", activity.DisplayName); } }
public BatchStateMachineTests() { _sagaRepository = new InMemorySagaRepository <BatchState>(); _stateMachine = new BatchStateMachine(); _testHarness = new InMemoryTestHarness(); _testHarness.OnConfigureInMemoryReceiveEndpoint += ConfigureInMemoryReceiveEndpoint; _testHarness.OnConfigureInMemoryBus += ConfigureInMemoryBus; }