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_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 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_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_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 ValidRdfParseTests(ParseFileTestFixture fixture)
{
//_fixture = fixture;
_blobStorage = fixture.BlobStorage;
_harness = new InMemoryTestHarness();
_consumer = _harness.Consumer(() => new ParseFileCommandHandler(fixture.BlobStorage));
}
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 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 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.ExecuteSqlRawAsync("TRUNCATE TABLE EfCoreAudit");
}
_harness = new InMemoryTestHarness();
_harness.OnConnectObservers += bus =>
{
bus.ConnectSendAuditObservers(_store);
bus.ConnectConsumeAuditObserver(_store);
};
_consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
}
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 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_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 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 A_consumer_is_being_tested()
{
_harness = new InMemoryTestHarness();
_consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A(), context => context.ResponseAddress = _harness.BusAddress);
}
public ValidCifParseTests(ParseFileTestFixture fixture)
{
_blobStorage = fixture.BlobStorage;
var settings = ConfigurationManager.AppSettings.TestHarnessSettings();
_harness = new InMemoryTestHarness();
_harness.TestTimeout = TimeSpan.FromSeconds(settings.Timeout);
_consumer = _harness.Consumer(() => new ParseFileCommandHandler(fixture.BlobStorage));
}
public async Task A_consumer_is_being_tested()
{
_harness = new InMemoryTestHarness();
_consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
}
public void SetUp()
{
userJwt = "Example_jwt";
harness = new InMemoryTestHarness();
jwtValidationMock = new Mock <ITokenValidator>();
consumerTestHarness = harness.Consumer(() => new CheckTokenConsumer(jwtValidationMock.Object));
}
public FileTests(IndexingFixture indexingFixture)
{
_fileId = Guid.NewGuid();
index = string.Empty;
type = string.Empty;
doc = null;
docAsUpsert = null;
string _someField = Guid.NewGuid().ToString();
string _someValue = Guid.NewGuid().ToString();
_fakeIndex = new List <IIndexRequest <dynamic> >();
_mongoDb = indexingFixture.MongoDb;
var files = _mongoDb.GetCollection <BsonDocument>("Files");
files.InsertOne(
new BsonDocument("_id", _fileId)
.Add("Name", "Processed.mol")
.Add("Status", "Processed")
.Add(_someField, _someValue));
var list = new List <BsonDocument>();
for (int i = 0; i < 10; i++)
{
list.Add(new BsonDocument("_id", Guid.NewGuid()).Add("Name", i.ToString()));
}
files.InsertMany(list);
_file = _mongoDb.GetCollection <dynamic>("Files").Find(new BsonDocument("_id", _fileId)).First();
((IDictionary <string, object>)_file).Remove("_id");
((IDictionary <string, object>)_file).Add("id", _fileId);
_elasticClientMock = new Mock <IElasticClient>();
_elasticClientMock
.Setup(m => m.IndexAsync <object>(It.IsAny <IIndexRequest>(), null, default(CancellationToken)))
.Returns(Task.FromResult(new Mock <IIndexResponse>().Object))
.Callback <IIndexRequest <object>, Func <IndexDescriptor <object>, IIndexRequest>, CancellationToken>((a, s, c) => {
_fakeIndex.Add(a);
index = a.Index.Name;
type = a.Type.Name;
}).Verifiable();
_elasticClientMock.Setup(m => m.UpdateAsync <object, object>(It.IsAny <IUpdateRequest <object, object> >(), default(CancellationToken)))
.Returns(Task.FromResult(new Mock <IUpdateResponse <object> >().Object))
.Callback <IUpdateRequest <object, object>, CancellationToken>((a, c) =>
{
index = a.Index.Name;
type = a.Type.Name;
docAsUpsert = a.DocAsUpsert;
doc = a.Doc as IDictionary <string, object>;
}).Verifiable();
_harness = new InMemoryTestHarness();
_consumer = _harness.Consumer(() => new FileEventHandler(_elasticClientMock.Object, _mongoDb, _blobStorage));
_harness.Start().Wait();
}
protected override Task Arrange()
{
_observer = new EndpointObserver(Harness);
Harness.OnConfigureBus += cfg =>
{
cfg.ConnectBusObserver(new BusObserver(Harness, _observer));
};
Harness.OnConfigureReceiveEndpoint += x => x.ConcurrentMessageLimit = 1;
_consumer = Harness.Consumer <SubmitOrderConsumer>();
return(Task.CompletedTask);
}
public async Task Send_message_to_test_consumer()
{
_harness = new InMemoryTestHarness();
_harness.OnConfigureInMemoryBus += configurator => configurator.UseMongoDbAuditStore(Database, AuditCollectionName);
ConsumerTestHarness <TestConsumer> consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
IReceivedMessage <A> consumed = consumer.Consumed.Select <A>().First();
_audit = await GetAuditRecordsForMessage(consumed.Context.MessageId.Value);
}
public async Task Send_message_to_test_consumer()
{
_harness = new InMemoryTestHarness();
_harness.OnConfigureInMemoryBus += configurator => configurator.ConnectConsumeAuditObserver(AuditStore);
ConsumerTestHarness <TestConsumer> consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
_consumed = consumer.Consumed.Select <A>().First();
List <AuditDocument> audit = await GetAuditRecords("Consume");
_auditDocument = audit.Single();
}
public async Task Setup()
{
_consumer = Harness.Consumer <CreateCommandConsumer>();
Harness.OnConfigureBus += configurator =>
{
var sec5 = TimeSpan.FromSeconds(5);
configurator.UseRetry(x => x.Exponential(2, sec5, sec5, sec5));
};
await Harness.Start();
await Harness.Bus.Publish(new CreateCommand
{
Name = "Test"
});
}
public async Task Send_message_to_test_consumer()
{
_harness = new InMemoryTestHarness();
_harness.OnConfigureInMemoryBus += configurator =>
{
configurator.ConnectConsumeAuditObserver(AuditStore);
configurator.ConnectSendAuditObservers(AuditStore);
};
ConsumerTestHarness <TestConsumer> consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
IReceivedMessage <A> consumed = consumer.Consumed.Select <A>().First();
_audit = await GetAuditRecordsForMessage(consumed.Context.MessageId.Value);
}
public async Task Setup()
{
_consumer = Harness.Consumer <TestCommandConsumer>();
Harness.OnConfigureBus += cfg =>
{
cfg.ReceiveEndpoint(Harness.InputQueueName + "_fault", x =>
{
_faultHandler = Harness.Handled <Fault <FailingCommand> >(x);
});
};
await Harness.Start();
await Harness.InputQueueSendEndpoint.Send <FailingCommand>(new { CorrelationId = NewId.NextGuid() }, context =>
{
context.CorrelationId = _correlationId;
});
}
public async Task Send_message_to_test_consumer()
{
_store = new EntityFrameworkAuditStore(
LocalDbConnectionStringProvider.GetLocalDbConnectionString(), "audit");
using (var dbContext = _store.AuditContext)
await dbContext.Database.ExecuteSqlCommandAsync("TRUNCATE TABLE audit");
_harness = new InMemoryTestHarness();
_harness.OnConnectObservers += bus =>
{
bus.ConnectSendAuditObservers(_store);
bus.ConnectConsumeAuditObserver(_store);
};
_consumer = _harness.Consumer <TestConsumer>();
await _harness.Start();
await _harness.InputQueueSendEndpoint.Send(new A());
}
public FileEventHandlersTests(TestFixture fixture)
{
_fixture = fixture;
_records = _fixture.Database.GetCollection <BsonDocument>("Records");
_files = _fixture.Database.GetCollection <BsonDocument>("Files");
_metadatas = _fixture.Database.GetCollection <BsonDocument>("Metadata");
_testFileId = Guid.NewGuid();
_files.InsertOne(new
{
_id = _testFileId,
Properties = new { Fields = new[] { "F1" } }
}.ToBsonDocument());
_fileEventsConsumer = _fixture.Harness.Consumer(() => new FileEventHandlers(_fixture.Database));
_fixture.Harness.Start().Wait();
}
public async Task Setup()
{
_consumer = Harness.Consumer <TestCommandConsumer>();
await Harness.Start();
_publish = new PublishObserver(Harness);
Harness.Bus.ConnectPublishObserver(_publish);
_send = new SendObserver(Harness);
Harness.Bus.ConnectSendObserver(_send);
_correlationId = NewId.NextGuid();
await Harness.Bus.Publish <TestEvent>(new
{
CorrelationId = _correlationId
});
}
public async Task Should_be_able_to_create_standalone_consumer_test_in_memory()
{
var harness = new InMemoryTestHarness();
ConsumerTestHarness <MyConsumer> consumer = harness.Consumer <MyConsumer>();
await harness.Start();
try
{
await harness.InputQueueSendEndpoint.Send(new PingMessage());
Assert.That(harness.Consumed.Select <PingMessage>().Any(), Is.True);
Assert.That(consumer.Consumed.Select <PingMessage>().Any(), Is.True);
}
finally
{
await harness.Stop();
}
}
public async Task A_consumer_is_being_tested()
{
_loggerMock = LoggerUtils.LoggerMock <PersonSearchCompletedConsumer>();
_searchApiNotifierMock = new Mock <ISearchApiNotifier <PersonSearchAdapterEvent> >();
_harness = new InMemoryTestHarness();
_requestId = Guid.NewGuid();
var fakePersonSearchStatus = new FakePersonSearchCompleted
{
SearchRequestId = _requestId,
TimeStamp = DateTime.Now
};
_sut = _harness.Consumer(() => new PersonSearchCompletedConsumer(_searchApiNotifierMock.Object, _loggerMock.Object));
await _harness.Start();
await _harness.BusControl.Publish <PersonSearchCompleted>(fakePersonSearchStatus);
}