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_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 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 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 If_Package_not_valid_Sync_process_is_set_to_failed()
{
// Arrange
var harness = new InMemoryTestHarness();
try
{
var ar = new ArchiveRecord {
ArchiveRecordId = "344"
};
var mutationId = 999;
var errMsg = "Some other error message";
var appendResult = new RepositoryPackageInfoResult {
Valid = false, Success = true, ErrorMessage = errMsg
};
repositoryManager.Setup(e => e.ReadPackageMetadata(It.IsAny <string>(), It.IsAny <string>())).Returns(appendResult);
var readMetadataConsumer = harness.Consumer(() => readPackageMetadataConsumer.Object);
harness.Consumer(() => new ReadPackageMetadataConsumer(repositoryManager.Object));
harness.Consumer(() => readPackageMetadataConsumer.Object);
await harness.Start();
// Act
await harness.InputQueueSendEndpoint.Send <IArchiveRecordAppendPackageMetadata>(new
{
ArchiveRecord = ar,
MutationId = mutationId
});
// Assert
// did the endpoint consume the message
Assert.That(await harness.Consumed.Any <IArchiveRecordAppendPackageMetadata>());
// did the actual consumer consume the message
Assert.That(await readMetadataConsumer.Consumed.Any <IArchiveRecordAppendPackageMetadata>());
// the consumer publish the event
Assert.That(await harness.Published.Any <IArchiveRecordUpdated>());
// ensure that no faults were published by the consumer
Assert.That(await harness.Published.Any <Fault <IArchiveRecordUpdated> >(), Is.False);
// did the actual consumer consume the message
var message = harness.Published.Select <IArchiveRecordUpdated>().First().Context.Message;
// Assert
message.ActionSuccessful.Should().Be(false);
message.MutationId.Should().Be(mutationId);
message.ErrorMessage.Should().Be(errMsg);
}
finally
{
await harness.Stop();
}
}
public async Task If_Package_is_valid_the_package_is_scheduled_for_sync()
{
// Arrange
var harness = new InMemoryTestHarness();
try
{
var ar = new ArchiveRecord {
ArchiveRecordId = "478"
};
var mutationId = 777;
var errMsg = string.Empty;
var appendResult = new RepositoryPackageInfoResult
{
Valid = true, Success = true, ErrorMessage = errMsg, PackageDetails = new RepositoryPackage {
ArchiveRecordId = ar.ArchiveRecordId
}
};
repositoryManager.Setup(e => e.ReadPackageMetadata(It.IsAny <string>(), It.IsAny <string>())).Returns(appendResult);
var readMetadataConsumer = harness.Consumer(() => readPackageMetadataConsumer.Object);
harness.Consumer(() => new ReadPackageMetadataConsumer(repositoryManager.Object));
harness.Consumer(() => readPackageMetadataConsumer.Object);
await harness.Start();
// Act
await harness.InputQueueSendEndpoint.Send <IArchiveRecordAppendPackageMetadata>(new
{
ArchiveRecord = ar,
MutationId = mutationId
});
// Assert
// did the endpoint consume the message
Assert.That(await harness.Consumed.Any <IArchiveRecordAppendPackageMetadata>());
// did the actual consumer consume the message
Assert.That(await readMetadataConsumer.Consumed.Any <IArchiveRecordAppendPackageMetadata>());
Assert.That(await harness.Sent.Any <IScheduleForPackageSync>());
var message = harness.Sent.Select <IScheduleForPackageSync>().First().Context.Message;
// Assert
message.Workload.ArchiveRecord.ArchiveRecordId.Should().Be(ar.ArchiveRecordId);
message.Workload.MutationId.Should().Be(mutationId);
}
finally
{
await harness.Stop();
}
}
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 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 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 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();
}
}
public async Task Should_publish_order_submited_event()
{
var harness = new InMemoryTestHarness();
harness.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.True(harness.Published.Select <OrderSubmitted>().Any());
}
finally
{
await harness.Stop();
}
}
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 ScopeConsumerFactory <MyConsumer>(new AutofacConsumerScopeProvider(new SingleLifetimeScopeProvider(_container),
"message", (b, ct) =>
{
})));
await _harness.Start();
}
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 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_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_respond_with_acceptance_if_ok()
{
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 <OrderSubmissionAccepted>(new {
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
await harness.InputQueueSendEndpoint.Send <SubmitOrder>(new {
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = "12345"
});
Assert.Equal(response.Message.OrderId, orderId);
Assert.True(consumer.Consumed.Select <SubmitOrder>().Any());
Assert.True(harness.Sent.Select <OrderSubmissionAccepted>().Any());
}
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();
var requestClient = await harness.ConnectRequestClient <ISubmitOrder>();
await harness.InputQueueSendEndpoint.Send <ISubmitOrder>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(harness.Published.Select <OrderSubmitted>().Any(), Is.True);
}
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 Should_respond_with_rejected_if_test_customer_number()
{
var harness = new InMemoryTestHarness();
var consumer = harness.Consumer <SubmitOrderConsumer>();
await harness.Start();
try
{
var orderId = NewId.NextGuid();
var requestClient = await harness.ConnectRequestClient <ISubmitOrder>();
var response = await requestClient.GetResponse <OrderSubmissionRejected>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumberFail
});
Assert.That(response.Message.OrderId, Is.EqualTo(orderId));
Assert.That(consumer.Consumed.Select <ISubmitOrder>().Any(), Is.True);
Assert.That(harness.Sent.Select <OrderSubmissionRejected>().Any(), Is.True);
}
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 Person()
{
FirstName = "",
LastName = "lastName",
DateOfBirth = new DateTime(2001, 1, 1)
}
});
}
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();
var requestClient = await harness.ConnectRequestClient <ISubmitOrder>();
await harness.InputQueueSendEndpoint.Send <ISubmitOrder>(new
{
OrderId = orderId,
InVar.Timestamp,
CustomerNumber = customerNumber
});
Assert.That(consumer.Consumed.Select <ISubmitOrder>().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 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 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_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 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 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_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_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_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();
}
}
