public async Task storing_an_aggregate_resets_list_of_changes()
{
var agg = PersonAggregateFactory.Create($"persons-{Guid.NewGuid()}", "Joe");
await Repository.StoreAsync(agg);
Assert.That(agg.Changes, Is.Empty);
}
public void SearchPerson_by_last_name_wildchar_Test()
{
//ARRANGE
//set up a person
var personId = Guid.NewGuid();
var person = PersonAggregateFactory.BuildPersonSearchModel(personId, "John", "Doe");
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//create an unique index
var indexId = Guid.NewGuid();
var indexName = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, indexId);
var indexContext = new IndexContext(typeof(EsPersonSearch), indexName);
//set up document CRUD controller and create a mock document
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var documentDispatcher = new DocumentDispatcher(clientFactory, indexManager, responseHandler);
var documentclient = new DocumentController(documentDispatcher, indexManager, responseHandler);
try
{
var index = indexManager.BuildIndexName(indexContext);
var context = new UpsertDocumentContext <EsPersonSearch>(personId)
{
Document = person, IndexContext = indexContext
};
//create person document
documentclient.UpsertDocument(context);
Thread.Sleep(1000);
var searchResponse = client
.Search <EsPersonSearch>(s => s.Query(q =>
q.Wildcard(m => m.Field(g => g.PersonName.LastName)
.Value("D*e")))
.Index(index)
.Explain());
var allRecords = client
.Search <EsPersonSearch>(q => q
.Index(index));
//ASSERT
Assert.IsTrue(searchResponse.IsValid);
Assert.AreEqual(1, searchResponse.Documents.Count());
Assert.AreEqual(personId, searchResponse.Documents.First().Id);
Assert.AreEqual("John", searchResponse.Documents.First().PersonName.FirstName);
Assert.AreEqual("Doe", searchResponse.Documents.First().PersonName.LastName);
}
finally
{
indexManager.DeleteIndex(indexContext);
}
}
public async Task saving_an_aggregate_clears_list_of_changes()
{
var id = $"Persons-{Guid.NewGuid()}";
var p = PersonAggregateFactory.Create(id, "Mary");
await Repository.StoreAsync(p);
Assert.That(p.Changes, Is.Empty);
}
public async Task cannot_load_aggregate_with_invalid_version_param()
{
var id = $"persons-{Guid.NewGuid()}";
var agg = PersonAggregateFactory.Create(id, "Joe");
await Repository.StoreAsync(agg);
Assert.That(async() => await Repository.GetAsync <PersonAggregate>(agg.Id, -1), Throws.Exception.TypeOf <InvalidOperationException>());
}
public async Task can_store_and_load_aggregate()
{
var id = $"Persons-{Guid.NewGuid()}";
await Repository.StoreAsync(PersonAggregateFactory.Create(id, "Joe"));
var pl = await Repository.GetAsync <PersonAggregate>(id);
Assert.That(pl.Version, Is.EqualTo(1));
}
public async Task can_store_and_load_aggregates_below_page_size_treshold()
{
var id = $"persons-{Guid.NewGuid()}";
await Repository.StoreAsync(PersonAggregateFactory.Create(id, "Joe"));
var agg = await Repository.GetAsync <PersonAggregate>(id);
Assert.That(agg.Version, Is.EqualTo(1));
}
public async Task concurrent_updates_cause_WrongExpectedVersionException()
{
var id = $"persons-{Guid.NewGuid()}";
await Repository.StoreAsync(PersonAggregateFactory.Create(id, "Joe"));
var agg = await Repository.GetAsync <PersonAggregate>(id);
await TestingUtils.UpdateOutOfSession(id, Repository);
TestingUtils.Rename(agg, "New name");
Assert.That(async() => { await Repository.StoreAsync(agg); }, Throws.Exception.TypeOf <ConcurrencyException>());
}
public async Task concurrent_updates_throw_AggregateConcurrencyException()
{
var id = $"Persons-{Guid.NewGuid()}";
await Repository.StoreAsync(PersonAggregateFactory.Create(id, "Joe"));
var loadedAggregate = await Repository.GetAsync <PersonAggregate>(id);
await TestingUtils.UpdateOutOfSession(id, Repository);
TestingUtils.Rename(loadedAggregate, "Gary");
Assert.That(async() => await Repository.StoreAsync(loadedAggregate), Throws.Exception.TypeOf <AggregateConcurrencyException>());
}
public async Task can_load_requested_version_of_aggregate()
{
const int NrOfEventsToAdd = 5;
const int FinalVersion = 6;
const int RequestedVersion = 2;
var id = $"persons-{Guid.NewGuid()}";
var agg = PersonAggregateFactory.CreateWithUncommitedUpdates(id, NrOfEventsToAdd);
await Repository.StoreAsync(agg);
var loadedAggregate = await Repository.GetAsync <PersonAggregate>(id, RequestedVersion);
Assert.That(agg.Version, Is.EqualTo(FinalVersion));
Assert.That(loadedAggregate.Version, Is.EqualTo(RequestedVersion));
}
public void DispatchToKafkaServerTest1()
{
//ARRANGE
var documentId = Guid.NewGuid();
var document = PersonAggregateFactory.BuildPersonSearchModel(documentId, "Daniel1", "Georgiev1");
var dependencyResolver = new DependencyResolverMock();
////create an unique index
var indexId = Guid.NewGuid();
var indexName = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, indexId);
var indexContext = new IndexContext(typeof(EsPersonSearch), indexName);
var producerConfigManager = new ProducerConfigManager(dependencyResolver);
dependencyResolver.RegisterFactory <IConfigurationProvider>((t) => new ClientIdProvider(), Lifetime.Transient);
dependencyResolver.RegisterFactory <IConfigurationProvider>((t) => new EndPoindProvider(), Lifetime.Transient);
dependencyResolver.RegisterFactory <IConfigurationProvider>((t) => new ProducerTopicConfigProvider(), Lifetime.Transient);
try
{
var context = new UpsertDocumentContext <EsPersonSearch>(documentId)
{
Document = document, IndexContext = indexContext
};
var dispatcher = new KafkaDispatcherConfuence(producerConfigManager);
var documentController = new DocumentControllerMock(dispatcher);
//ACT
documentController.UpsertDocument(context);
//.Wait();
//ASSERT
}
finally
{
}
}
async Task CreateAndStoreUpdatedAggregate(string aggId, int nrOfUpdates)
{
var p = PersonAggregateFactory.CreateWithUncommitedUpdates(aggId, nrOfUpdates);
await Repository.StoreAsync(p);
}
async Task CreateAndPersistAggregateThatExceedesPageSizeTreshold(string id)
{
var agg = PersonAggregateFactory.CreateWithUncommitedUpdates(id, OverflownPageSize);
await Repository.StoreAsync(agg);
}
public void BuildBoolQueryTest_with_nested_query()
{
//ARRANGE
var personId = Guid.NewGuid();
var person = PersonAggregateFactory.BuildPersonSearchModel(personId, "John", "Doe");
var person1Id = Guid.NewGuid();
var person1 = PersonAggregateFactory.BuildPersonSearchModel(personId, "Jane", "Doe");
var dependencyResolver = new DependencyResolverMock();
var organisationSearch = new EsOrganisationSearch {
OrganisationName = "Organisation1"
};
person.Organisations.Add(organisationSearch);
dependencyResolver.RegisterFactory <IQueryClauseBuilder <FieldContext> >(t => new TermClauseBuilder(), Lifetime.Transient);
dependencyResolver.RegisterFactory <IQueryClauseBuilder <NestedFieldContext> >(t => new NestedClauseBuilder(), Lifetime.Transient);
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//create an unique index
var indexId = Guid.NewGuid();
var indexName = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, indexId);
var indexContext = new IndexContext(typeof(EsPersonSearch), indexName);
//set up document CRUD controller and create a mock document
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var documentDispatcher = new DocumentDispatcher(clientFactory, indexManager, responseHandler);
var documentclient = new DocumentController(documentDispatcher, indexManager, responseHandler);
try
{
var context = new UpsertDocumentContext <EsPersonSearch>(personId)
{
Document = person, IndexContext = indexContext
};
documentclient.UpsertDocument(context);
var context1 = new UpsertDocumentContext <EsPersonSearch>(person1Id)
{
Document = person1, IndexContext = indexContext
};
documentclient.UpsertDocument(context1);
Thread.Sleep(1000);
var queryContext = new QueryContext
{
SearchFields = new[]
{
new NestedFieldContext {
Path = "Organisations", Value = "Organisation1", PropertyName = "organisations.organisationName"
},
},
};
var queryBuilder = new BoolQueryBulder <EsPersonSearch>(dependencyResolver);
var query = queryBuilder.BuildQuery(queryContext);
var index = indexManager.BuildIndexName(indexContext);
var searchResponse = client.Search <EsPersonSearch>(s => s.Query(query)
.Index(index));
var documents = searchResponse.Documents;
//ASSERT
Assert.IsTrue(searchResponse.IsValid);
Assert.AreEqual(1, documents.Count);
}
finally
{
indexManager.DeleteIndex(indexContext);
}
}
public void BuildBoolMustQueryTest_multi_records_found()
{
//ARRANGE
var personId = Guid.NewGuid();
var person = PersonAggregateFactory.BuildPersonSearchModel(personId, "John", "Doe");
var person1Id = Guid.NewGuid();
var person1 = PersonAggregateFactory.BuildPersonSearchModel(personId, "Jane", "Doe");
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//create an unique index
var indexId = Guid.NewGuid();
var indexName = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, indexId);
var indexContext = new IndexContext(typeof(EsPersonSearch), indexName);
//set up document CRUD controller and create a mock document
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
dependencyResolver.RegisterFactory <ISearchClauseBuilder <EsPersonSearch> >((t) => new SearchClauseBuilder <EsPersonSearch>(new BoolQueryBulder <EsPersonSearch>(dependencyResolver), new SortClauseBuilder <EsPersonSearch>(), indexManager), Lifetime.Transient);
dependencyResolver.RegisterFactory <ResultProjector <EsPersonSearch, QmPersonSearchResult> >(t => new PersonResultProjector(), Lifetime.Transient);
dependencyResolver.RegisterFactory <IQueryClauseBuilder <FieldContext> >(t => new TermClauseBuilder(), Lifetime.Transient);
dependencyResolver.RegisterFactory <IQueryClauseBuilder <NestedFieldContext> >(t => new NestedClauseBuilder(), Lifetime.Transient);
var documentDispatcher = new DocumentDispatcher(clientFactory, indexManager, responseHandler);
var documentclient = new DocumentController(documentDispatcher, indexManager, responseHandler);
var searchEngine = new SearchEngine(clientFactory, dependencyResolver, responseHandler);
try
{
var context = new UpsertDocumentContext <EsPersonSearch>(personId)
{
Document = person, IndexContext = indexContext
};
documentclient.UpsertDocument(context);
var context1 = new UpsertDocumentContext <EsPersonSearch>(person1Id)
{
Document = person1, IndexContext = indexContext
};
documentclient.UpsertDocument(context1);
Thread.Sleep(1000);
var queryContext = new QueryContext
{
SearchFields = new[]
{
new FieldContext {
Path = "PersonName.LastName", Value = "Doe"
}
},
IndexContext = new IndexContext <EsPersonSearch> {
IndexName = indexName
},
};
queryContext.SortContext.Fields.Add(new SortField {
Path = "PersonName.FirstName"
});
var searchResponse = searchEngine.Search <EsPersonSearch, QmPersonSearchResult>(queryContext).Result;
var documents = searchResponse.Entities;
//ASSERT
Assert.AreEqual(2, documents.Count());
}
finally
{
indexManager.DeleteIndex(indexContext);
}
}
public void SearchPerson_by_organisation_Test()
{
//ARRANGE
var personId = Guid.NewGuid();
var organisationId1 = Guid.NewGuid();
var organisationId2 = Guid.NewGuid();
var person = PersonAggregateFactory.BuildPersonSearchModel(personId, "John", "Doe");
PersonAggregateFactory.AddPersonOrganisation(person, organisationId1, "TestOrganisation1");
PersonAggregateFactory.AddPersonOrganisation(person, organisationId2, "TestOrganisation2");
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//create an unique index
var indexId = Guid.NewGuid();
var indexName = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, indexId);
var indexContext = new IndexContext(typeof(EsPersonSearch), indexName);
//set up document CRUD controller and create a mock document
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var documentDispatcher = new DocumentDispatcher(clientFactory, indexManager, responseHandler);
var documentclient = new DocumentController(documentDispatcher, indexManager, responseHandler);
try
{
var index = indexManager.BuildIndexName(indexContext);
//create person document
var context = new UpsertDocumentContext <EsPersonSearch>(personId)
{
Document = person, IndexContext = indexContext
};
documentclient.UpsertDocument(context);
Thread.Sleep(1000);
var searchResponse = client
.Search <EsPersonSearch>(s =>
s.Query(q =>
q.Nested(nq =>
nq.Path(p => p.Organisations)
.Query(oq =>
oq.Match(m => m.Field(g => g.Organisations.First().OrganisationName)
.Query("TestOrganisation1")))))
.Index(index));
var allRecords = client
.Search <EsPersonSearch>(q => q
.Index(index));
//ASSERT
Assert.IsTrue(searchResponse.IsValid);
Assert.AreEqual(1, searchResponse.Documents.Count());
Assert.AreEqual(person.Id, searchResponse.Documents.First().Id);
Assert.AreEqual(2, searchResponse.Documents.First().Organisations.Count());
Assert.AreEqual("TestOrganisation1", searchResponse.Documents.First().Organisations.First().OrganisationName);
}
finally
{
indexManager.DeleteIndex(indexContext);
}
}
