public async Task ShouldSendResponseToBrokerWhenUserJwtIsValid() { object expectedErrors = null; Guid expectedBody = Guid.Empty; await harness.Start(); try { var requestClient = await harness.ConnectRequestClient <ICheckTokenRequest>(); var response = await requestClient.GetResponse <IOperationResult <Guid> >(new { UserJwt = userJwt }); Assert.IsTrue(response.Message.IsSuccess); Assert.AreEqual(expectedErrors, response.Message.Errors); Assert.AreEqual(expectedBody, response.Message.Body); Assert.IsTrue(consumerTestHarness.Consumed.Select <ICheckTokenRequest>().Any()); } finally { await harness.Stop(); } }
public async Task ShouldRetry_WhenMessageRetryIsUsed() { try { var testActivity = new ActivityTestContext <FirstFaultyActivity, FaultyArguments, FaultyLog>( harness, () => new FirstFaultyActivity(), null, null); harness.OnConfigureBus += bus => bus.UseMessageRetry(r => r.Immediate(2)); await harness.Start(); var routingSlipCompletedHandler = ConnectPublishHandler <RoutingSlipCompleted>(harness); var builder = new RoutingSlipBuilder(Guid.NewGuid()); builder.AddActivity(testActivity.Name, testActivity.ExecuteUri, new { }); await harness.Bus.Execute(builder.Build()); await routingSlipCompletedHandler; } finally { await harness.Stop(); } }
public async Task Should_respond_with_rejected_if_customer_is_test() { var harness = new InMemoryTestHarness(); ConsumerTestHarness <SubmitOrderConsumer> consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { Guid orderId = NewId.NextGuid(); IRequestClient <SubmitOrder> requestClient = await harness.ConnectRequestClient <SubmitOrder>(); Response <OrderSubmissionRejected> response = await requestClient.GetResponse <OrderSubmissionRejected>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "TEST12345" }); // assert response.Message.OrderId.Should().Be(orderId); consumer.Consumed.Select <SubmitOrder>().Should().NotBeNullOrEmpty(); harness.Sent.Select <OrderSubmissionRejected>().Should().NotBeNullOrEmpty(); } finally { await harness.Stop(); } }
public async Task Should_publish_order_submitted_event() { var harness = new InMemoryTestHarness(); ConsumerTestHarness <SubmitOrderConsumer> consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { Guid orderId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "12345" }); harness.Published.Select <OrderSubmitted>().Should().NotBeNullOrEmpty(); } finally { await harness.Stop(); } }
public async Task Should_generate_a_graph_of_the_message_flow() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(2), TestInactivityTimeout = TimeSpan.FromSeconds(2) }; harness.Consumer(() => new AFooConsumer()); harness.Consumer(() => new BFooConsumer()); harness.Consumer(() => new CFooConsumer()); harness.Consumer(() => new DFooConsumer()); harness.Consumer(() => new EFooConsumer()); EndpointConvention.Map <EFoo>(harness.InputQueueAddress); await harness.Start(); await harness.Bus.Publish <AFoo>(new { InVar.CorrelationId }); await harness.Bus.Publish <BFoo>(new { InVar.CorrelationId }); await harness.OutputTimeline(TestContext.Out, options => options.IncludeAddress()); await harness.Stop(); }
public async Task Test_thing() { var harness = new InMemoryTestHarness(); harness.OnConfigureInMemoryBus += Harness_OnConfigureInMemoryBus; var saga = harness.StateMachineSaga(new TestSagaStateMachine(), new InMemorySagaRepository <TestSagaState>(), "saga"); var consumer = harness.Consumer <TestConsumer>("consumer"); await harness.Start(); try { var values = Enumerable.Range(0, 16).Select(i => Guid.NewGuid()).ToArray(); var response = await harness.Bus.Request <TestSagaRequest, TestSagaResponse>(new TestSagaRequest() { CorrelationId = Guid.NewGuid(), Values = values }); response.Message.Values.Should().HaveCount(16); } finally { await harness.Stop(); } }
public async Task CreateAsync_Should_Publish_Event_Successfully() { //Arrange var context = Context; var harness = new InMemoryTestHarness(); await harness.Start(); IOfficeBusiness officeBusiness = new OfficeBusiness(context, _mapper, _cache, harness.Bus); CreateOfficeCommand command = new CreateOfficeCommand { Location = "Amsterdam", OpenTime = DateTime.Now.TimeOfDay, CloseTime = DateTime.Now.AddHours(1).TimeOfDay }; //Act await officeBusiness.CreateAsync(command); //Assert try { Assert.True(await harness.Published.Any <OfficeCreated>()); } finally { await harness.Stop(); } }
public async Task BuildingFlowGraph_ShouldBuild() { EndpointConvention.Map <EFoo>(new Uri("queue:input-queue")); var harness = new InMemoryTestHarness() { TestTimeout = TimeSpan.FromSeconds(1) }; harness.Consumer(() => new AFooConsumer()); harness.Consumer(() => new BFooConsumer()); harness.Consumer(() => new CFooConsumer()); harness.Consumer(() => new DFooConsumer()); harness.Consumer(() => new EFooConsumer()); await harness.Start(); await harness.Bus.Publish <AFoo>(new { CorrelationId = Guid.NewGuid() }); await harness.Bus.Publish <BFoo>(new { CorrelationId = Guid.NewGuid() }); var graph = await GraphGenerator.Generate(harness); var converstationGraphs = string.Join(Environment.NewLine, graph.Select(StringGraphRenderer.Render)); await harness.Stop(); this.Assent(converstationGraphs); }
public async Task Should_handle_the_stop_state() { var harness = new InMemoryTestHarness(); StateMachineSagaTestHarness <Instance, TestStateMachine> saga = harness.StateMachineSaga <Instance, TestStateMachine>(_machine); var sagaId = Guid.NewGuid(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send(new Start { CorrelationId = sagaId }); await harness.InputQueueSendEndpoint.Send(new Stop { CorrelationId = sagaId }); Assert.IsTrue(harness.Consumed.Select <Start>().Any(), "Start not received"); Assert.IsTrue(harness.Consumed.Select <Stop>().Any(), "Stop not received"); var instance = saga.Created.ContainsInState(sagaId, _machine, _machine.Final); Assert.IsNotNull(instance, "Saga instance not found"); } finally { await harness.Stop(); } }
public async Task Should_publish_the_completed_event() { _harness = new InMemoryTestHarness(); _activity = _harness.Activity <TestActivity, TestArguments, TestLog>(); await _harness.Start(); _completed = _harness.SubscribeHandler <RoutingSlipCompleted>(); _activityCompleted = _harness.SubscribeHandler <RoutingSlipActivityCompleted>(); _trackingNumber = NewId.NextGuid(); var builder = new RoutingSlipBuilder(_trackingNumber); builder.AddSubscription(_harness.BusAddress, RoutingSlipEvents.All); builder.AddActivity(_activity.Name, _activity.ExecuteAddress, new { Value = "Hello" }); builder.AddVariable("Variable", "Knife"); await _harness.Bus.Execute(builder.Build()); await _completed; }
public async Task Should_insert_new_state_instance_on_submitted() { var orderStateMachine = new OrderStateMachine(); var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(5) }; var saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(orderStateMachine); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.Bus.Publish <IOrderSubmitted>(new { OrderId = orderId, ExternalOrderId = "00000001" }); 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.ExternalOrderId, Is.EqualTo("00000001")); } finally { await harness.Stop(); } }
public async Task Should_create_a_state_instance() { var harness = new InMemoryTestHarness(); StateMachineSagaTestHarness <OrderState, OrderStateMachine> saga = harness.StateMachineSaga <OrderState, OrderStateMachine>(new OrderStateMachine()); await harness.Start(); try { Guid orderId = NewId.NextGuid(); await harness.Bus.Publish <OrderSubmitted>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "12345" }); Guid?instanceId = await saga.Exists(orderId, x => x.Submitted); instanceId.Should().Be(orderId); OrderState instance = saga.Sagas.Contains(instanceId.Value); instance.CustomerNumber.Should().Be("12345"); } finally { await harness.Stop(); } }
public async Task Should_Test_ExecutePubmedSearchConsumer() { //Arrange var pubmedWebClient = new Mock <IPubmedWebClient>(); var mockFileService = new Mock <IFileService>(); var mockUnitOfWork = new Mock <ILsUnitOfWork>(); var pubmedService = new PubmedService(pubmedWebClient.Object, mockFileService.Object, mockUnitOfWork.Object); var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer(() => new ExecutePubmedSearchConsumer(pubmedService)); //Act await harness.Start(); //Assert try { await harness.InputQueueSendEndpoint.Send <IExecutePubmedSearchCommand>(new { ProjectId = default(Guid), LivingSearchId = default(Guid), SearchTerm = default(String), BatchSize = default(Int32) }); Assert.True(harness.Consumed.Select <IExecutePubmedSearchCommand>().Any()); Assert.True(consumerHarness.Consumed.Select <IExecutePubmedSearchCommand>().Any()); } finally { await harness.Stop(); } }
public async Task Should_Test_ExecuteBioRxivSearchConsumer() { //Arrange var mockBiorxivService = new Mock <IBiorxivService>(); var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer(() => new ExecuteBiorxivSearchConsumer(mockBiorxivService.Object)); //Act await harness.Start(); //Assert try { await harness.InputQueueSendEndpoint.Send <IExecuteBiorxivCovidFeedSearchCommand>(new { ProjectId = default(Guid), BiorxivSearchId = default(Guid), BatchSize = default(Int32), FileUri = default(string) }); Assert.True(harness.Consumed.Select <IExecuteBiorxivCovidFeedSearchCommand>().Any()); Assert.True(consumerHarness.Consumed.Select <IExecuteBiorxivCovidFeedSearchCommand>().Any()); } finally { await harness.Stop(); } }
public async Task FixtureSetUp() { _fixture = new Fixture(); _repoMock = new Mock <ISightingRepository <StubReportedSighting> >(); _protoTranslator = new Mock <IProtocolTranslator>(); _repertoir = new Mock <ISightingAnalyzerRepertoire>(); _routeRegistry = new Mock <IRouteRegistry>(); _harness = new InMemoryTestHarness(); _consumer = _harness.Consumer(() => new SightingInvestigationConsumer <StubReportedSighting>( _repoMock.Object, _protoTranslator.Object, _repertoir.Object, _routeRegistry.Object)); var ev = _fixture.Create <NewSightingReported>(); var chiefInvestigatorQ = new Uri("mq://chiefInspectorJapp"); var dbRecord = new StubReportedSighting(); var investigateCommand = new InvestigateSighting { Origin = "meh" }; _repertoir.Setup(e => e.All()).Returns(new[] { new RiggedAnalyzer(true), new RiggedAnalyzer(false) }); _routeRegistry.Setup(e => e.For <InvestigateSighting>()).Returns(chiefInvestigatorQ); _protoTranslator.Setup(e => e.TranslateToRecord <StubReportedSighting>(It.IsAny <NewSightingReported>(), It.Is <IAnalysisResults[]>(p => p.Length == 2))) .Returns(dbRecord); _protoTranslator.Setup(e => e.Translate(It.IsAny <NewSightingReported>(), It.Is <IAnalysisResults[]>(p => p.All(x => x.IsSuspicious)))) .Returns(investigateCommand); _repoMock.Setup(e => e.Add(dbRecord)).Returns(dbRecord); await _harness.Start(); await _harness.InputQueueSendEndpoint.Send(ev); }
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 <IOrderSubmitted>(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_test_the_consumer() { var harness = new InMemoryTestHarness("amqp://rabbitmq"); var consumerTestHarness = harness.Consumer <EventCreatedConsumer>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send <EventCreated>(new { Id = "1234", Name = "Testing EventConsumer" }); // did the endpoint consume the message Assert.IsTrue(harness.Consumed.Select <EventCreated>().Any()); // did the actual consumer consume the message Assert.IsTrue(consumerTestHarness.Consumed.Select <EventCreated>().Any()); } finally { await harness.Stop(); } }
public async Task InitializeAsync() { InterceptQuartzSystemTime(); var collection = new ServiceCollection() .AddMassTransitInMemoryTestHarness(cfg => { cfg.AddSagaStateMachine <TStateMachine, TInstance>().InMemoryRepository(); cfg.AddPublishMessageScheduler(); cfg.AddSagaStateMachineTestHarness <TStateMachine, TInstance>(); ConfigureMassTransit(cfg); }); Provider = collection.BuildServiceProvider(true); ConfigureService(collection); TestHarness = Provider.GetRequiredService <InMemoryTestHarness>(); TestHarness.OnConfigureInMemoryBus += configurator => { var nvc = new NameValueCollection { ["quartz.scheduler.instanceName"] = Guid.NewGuid().ToString() }; ISchedulerFactory schedulerFactory = new StdSchedulerFactory(nvc); configurator.UseInMemoryScheduler(schedulerFactory, out _scheduler); // Use only this cause Exception: Scheduler with name 'DefaultQuartzScheduler' already exists! //configurator.UseInMemoryScheduler(out _scheduler); }; await TestHarness.Start(); SagaHarness = Provider.GetRequiredService <IStateMachineSagaTestHarness <TInstance, TStateMachine> >(); Machine = Provider.GetRequiredService <TStateMachine>(); }
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 Person() { FirstName = "", LastName = "lastName", DateOfBirth = new DateTime(2001, 1, 1) } }); }
public async Task Should_publish_the_order_submitted_event() { var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = InVar.Id }); // did the endpoint consume the message Assert.That(await harness.Consumed.Any <SubmitOrder>()); // did the actual consumer consume the message Assert.That(await consumerHarness.Consumed.Any <SubmitOrder>()); // the consumer publish the event Assert.That(await harness.Published.Any <OrderSubmitted>()); // ensure that no faults were published by the consumer Assert.That(await harness.Published.Any <Fault <SubmitOrder> >(), Is.False); } finally { await harness.Stop(); } }
public async Task should_handle_the_initial_state() { var harness = new InMemoryTestHarness(); _machine = new InvestigationStateMachine(new List <Provider>()); StateMachineSagaTestHarness <Investigation, InvestigationStateMachine> saga = harness.StateMachineSaga <Investigation, InvestigationStateMachine>(_machine); await harness.Start(); var searchRequestedEvent = SearchRequested.Create(new PeopleSearchRequest("test", "test", "test")); try { await harness.InputQueueSendEndpoint.Send(searchRequestedEvent); Assert.IsTrue(harness.Consumed.Select <SearchRequested>().Any(), "Message not received"); Investigation instance = saga.Created.Select(x => x.CorrelationId == searchRequestedEvent.CorrelationId) .FirstOrDefault() ?.Saga; Assert.IsNotNull(instance, "Saga instance not found"); Assert.AreEqual(instance.CurrentState, nameof(_machine.Started)); } finally { await harness.Stop(); } }
public async Task Should_create_a_state_instance() { // Arrange (Given) var harness = new InMemoryTestHarness(); var fileHandlerStateMachine = new FileHandlerStateMachine(); var saga = harness.StateMachineSaga <FileHandlerState, FileHandlerStateMachine>(fileHandlerStateMachine); await harness.Start(); try { var fileId = NewId.NextGuid(); await harness.Bus.Publish <FileInfoSubmitted>(new { FileId = fileId, Timestamp = InVar.Timestamp, FileName = "filename.file", Folder = "c:/folder/" }); var instanceID = await saga.Exists(fileId, x => x.Submitted); var instance = saga.Sagas.Contains(instanceID.Value); Assert.NotNull(instanceID); Assert.True(saga.Created.Select(x => x.CorrelationId == fileId).Any()); } finally { await harness.Stop(); } }
public async Task Send_message_to_test_consumer() { // add migrations by calling // dotnet ef migrations add --context auditdbcontext --output-dir Migrations\\Audit audit_init DbContextOptionsBuilder <AuditDbContext> optionsBuilder = new DbContextOptionsBuilder <AuditDbContext>(). UseSqlServer(LocalDbConnectionStringProvider.GetLocalDbConnectionString(), m => { var executingAssembly = typeof(ContextFactory).GetTypeInfo().Assembly; m.MigrationsAssembly(executingAssembly.GetName().Name); m.MigrationsHistoryTable("__AuditEFMigrationHistoryAudit"); }); _store = new EntityFrameworkAuditStore(optionsBuilder.Options, "EfCoreAudit"); using (var dbContext = _store.AuditContext) { await dbContext.Database.MigrateAsync(); await dbContext.Database.ExecuteSqlCommandAsync("TRUNCATE TABLE EfCoreAudit"); } _harness = new InMemoryTestHarness(); _harness.OnConnectObservers += bus => { bus.ConnectSendAuditObservers(_store); bus.ConnectConsumeAuditObserver(_store); }; _harness.Consumer <TestConsumer>(); await _harness.Start(); await _harness.InputQueueSendEndpoint.Send(new A()); }
public async Task Setup() { var collection = new ServiceCollection() .AddSingleton <ILoggerFactory>(_ => new TestOutputLoggerFactory(true)) .AddSingleton(typeof(ILogger <>), typeof(Logger <>)) .AddMassTransitInMemoryTestHarness(cfg => { cfg.AddSagaRepository <FutureState>() .InMemoryRepository(); cfg.ApplyCustomMassTransitConfiguration(); ConfigureMassTransit(cfg); }); ConfigureServices(collection); Provider = collection.BuildServiceProvider(true); ConfigureLogging(); TestHarness = Provider.GetRequiredService <InMemoryTestHarness>(); TestHarness.OnConfigureInMemoryBus += configurator => { configurator.ApplyCustomBusConfiguration(); ConfigureInMemoryBus(configurator); }; await TestHarness.Start(); }
public async Task Should_Consume_TransactionCheckCommand() { var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer <BillingsSubscriptionsHandler>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send(new TransactionCheckCommand { Id = Guid.NewGuid().ToString(), ProfileId = Guid.NewGuid().ToString() }); // did the endpoint consume the message Assert.True(await harness.Consumed.Any <TransactionCheckCommand>()); // did the actual consumer consume the message Assert.True(await consumerHarness.Consumed.Any <TransactionCheckCommand>()); } finally { await harness.Stop(); } }
public void Register(IObjectContainer objectContainer) { objectContainer.RegisterInstanceAs(Mock.Of <IServiceProvider>()); objectContainer.RegisterInstanceAs(Mock.Of <IObjectStorage>()); objectContainer.RegisterTypeAs <JsonObjectSerializer, IObjectSerializer>(); objectContainer.RegisterTypeAs <GroupTransactionExecutionService, IGroupTransactionExecutionService>(); RegisterHandlers(objectContainer); objectContainer.RegisterInstanceAs <ICache>(new InMemoryCache()); objectContainer.RegisterTypeAs <MessageTypeService, IMessageTypeService>(); InMemoryTestHarness bus = new InMemoryTestHarness(); bus.AddConsumer <IGroupTransactionEvent>(objectContainer); bus.AddConsumer <IMockEventOne>(objectContainer); bus.AddConsumer <IMockEventTwo>(objectContainer); bus.AddConsumer <IMockEventThree>(objectContainer); bus.AddConsumer <IMockEventFour>(objectContainer); bus.Start().GetAwaiter().GetResult(); objectContainer.RegisterInstanceAs <InMemoryTestHarness>(bus); objectContainer.RegisterInstanceAs <IServiceBus>(new ServiceBus( bus.BusControl, Mock.Of <IContractValidatorService>(), objectContainer.Resolve <IBigMessageService>(), objectContainer.Resolve <ObjectStorageConfiguration>())); }
public async Task Should_not_publish_order_submitted_event_when_rejected() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(5) }; ConsumerTestHarness <SubmitOrderConsumer> consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "TEST12345" }); harness.Published.Select <OrderSubmitted>().Should().BeEmpty(); } 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)); ConsumerTestHarness <RealConsumer> 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_consume_submit_order_commands() { var harness = new InMemoryTestHarness { TestTimeout = TimeSpan.FromSeconds(5) }; ConsumerTestHarness <SubmitOrderConsumer> consumer = harness.Consumer <SubmitOrderConsumer>(); await harness.Start(); try { var orderId = NewId.NextGuid(); await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new { OrderId = orderId, InVar.Timestamp, CustomerNumber = "12345" }); consumer.Consumed.Select <SubmitOrder>().Should().NotBeNullOrEmpty(); harness.Sent.Select <OrderSubmissionAccepted>().Should().BeEmpty(); // because we do not set a RequestId when not using a request client harness.Sent.Select <OrderSubmissionRejected>().Should().BeEmpty(); } finally { await harness.Stop(); } }
public async Task Should_Consume_AccountIsCheckedEvent() { var harness = new InMemoryTestHarness(); var consumerHarness = harness.Consumer <AccountsSubscriptionsHandler>(); await harness.Start(); try { await harness.InputQueueSendEndpoint.Send(new AccountIsCheckedEvent { ProfileId = Guid.NewGuid().ToString() }); // did the endpoint consume the message Assert.True(await harness.Consumed.Any <AccountIsCheckedEvent>()); // did the actual consumer consume the message Assert.True(await consumerHarness.Consumed.Any <AccountIsCheckedEvent>()); } finally { await harness.Stop(); } }