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);
}
}
RebuildTask NewRebuildTask()
{
cancellation = new CancellationTokenSource();
var ioc = new DependencyResolverMock().Register <IProjection>(_ => projection);
var reader = new HistoryReaderMock().MockRead(history);
return(new RebuildTask(new ConsoleLogger(), ioc, reader, versioningRepo, checkpointRepo, cancellation.Token));
}
public void SearchNestedTypeTest()
{
//ARRANGE
var id = Guid.NewGuid();
//set up search client
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
//create index name
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
try
{
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.AutoMap()
.Properties(p => p.Nested <ChildClass>(n => n.Name(parent => parent.Children)))));
var createIndexRequest = client.CreateIndex(indexDescriptor);
var testClass = new ParentTestClass();
testClass.Children.Add(new ChildClass());
var createDocumentResponse = client.Create(testClass, d => d.Index(index)
.Type(typeof(ParentTestClass)));
Thread.Sleep(1000);
//ACT
//Search
var searchResponse = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Nested(nq =>
nq.Path(p => p.Children)
.Query(oq =>
oq.Match(m => m.Field(g => g.Children.First().Name)
.Query(testClass.Children.First().Name.ToString()))).IgnoreUnmapped()))
.Index(Indices.Index(index)));
var allRecords = client
.Search <ParentTestClass>(q => q
.Index(Indices.Index(index)));
//ASSERT
Assert.IsTrue(searchResponse.IsValid);
Assert.AreEqual(1, searchResponse.Documents.Count());
Assert.AreEqual(testClass.Id, searchResponse.Documents.First().Id);
Assert.AreEqual(1, searchResponse.Documents.First().Children.Count());
Assert.AreEqual(testClass.Children.First().Id, searchResponse.Documents.First().Children.First().Id);
}
finally
{
var deleteIndexResult = client.DeleteIndex(index);
}
}
public void Test()
{
//ARRANGE
//set up search client
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//delete existing index
var index = new IndexName {
Name = typeof(ParentTestClass).Name.ToLower(), Type = typeof(ParentTestClass)
};
var deleteIndexResult = client.DeleteIndex(Indices.Index(index));
//set up document CRUD controller and create a mock document
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
//var documentclient = new DocumentController(clientFactory, indexManager);
//dependencyResolver.RegisterFactory<IndexMapper<ParentTestClass>>(t => new TestIndexMapper(), Lifetime.Transient);
var testClass = new ParentTestClass();
testClass.Children.Add(new ChildClass());
//documentclient.CreateDocument(testClass);
this.CreateDocument(testClass, index, client);
var indexMeta = client.GetIndex(Indices.Index(index));
Thread.Sleep(1000);
//ACT
//Search
var searchResponse = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Nested(nq =>
nq.Path(p => p.Children)
.Query(oq =>
oq.Match(m => m.Field(g => g.Children.First().Name)
.Query(testClass.Children.First().Name.ToString()))).IgnoreUnmapped()))
.Index(Indices.Index(index)));
var allRecords = client
.Search <ParentTestClass>(q => q
.Index(Indices.Index(index)));
//ASSERT
Assert.IsTrue(searchResponse.IsValid);
Assert.AreEqual(1, searchResponse.Documents.Count());
Assert.AreEqual(testClass.Id, searchResponse.Documents.First().Id);
Assert.AreEqual(1, searchResponse.Documents.First().Children.Count());
Assert.AreEqual(testClass.Children.First().Id, searchResponse.Documents.First().Children.First().Id);
}
public void Create_person_search_index()
{
//ARRANGE
//var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
//create an unique index
var indexName = String.Format("{0}", typeof(EsPersonSearch).Name).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext <ParentTestClass>(indexName);
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
var indexDescriptor = new CreateIndexDescriptor(index).Mappings(map => map.Map <EsPersonSearch>(m => m.AutoMap()));
// .Mappings(map => map.Map<ParentTestClass>(m =>
// m.Properties(p => p.Keyword(d => d.Name(n => n.Email))).AutoMap()));
//var index = indexManager.BuildIndexName(indexContext);
//ACT
try
{
client.CreateIndex(indexDescriptor);
//indexManager.BuildIndex(index).Wait();
//Thread.Sleep(1000);
//var d = client.Get<EsPersonSearch>(new DocumentPath<EsPersonSearch>(new EsPersonSearch { Id = Guid.Parse("a8de6650-236e-46ff-b3b9-b0bb24f0a38b") })
// .Index(index));
var documents = client.Search <EsPersonSearch>(s =>
s.Query(q => q.MatchAll())
.Index(index));
var document = client.Search <EsPersonSearch>(s =>
s.Query(q => q.Match(m =>
m.Field(f => f.PersonName.LastName)
.Query("Doe")))
.Index(index));
var indexState = indexManager.GetIndexState(indexContext);
var providedName = indexState.Settings["index.provided_name"];
var propertiesMapped = indexState.Mappings.SelectMany(x => x.Value.Properties);
//ASSERT
Assert.AreEqual(indexName, providedName);
}
finally
{
//client.DeleteIndex(index);
}
}
public void MapPersonNamePropertyTests()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//create an unique index
var indexName = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, id).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext(typeof(EsPersonSearch), indexName);
var index = indexManager.GetIndex(indexContext).Result;
//ACT
try
{
Thread.Sleep(1000);
var indexReqiest = new GetIndexRequest(index);
var indexResponse = client.GetIndex(indexReqiest);
var indices = indexResponse.Indices.ToList();
var first = indices.First();
var mappings = first.Value.Mappings.Select(x => x.Value)
.SelectMany(x => x.Properties, (x, y) =>
{
return(new { y.Key, y.Value.Name, y.Value.Type, Properties = ((ObjectProperty)y.Value).Properties });
});
var nameProperty = mappings.First(x => x.Name.Name.Equals("personName", StringComparison.OrdinalIgnoreCase));
var firstNameProperty = nameProperty.Properties.First(x => x.Key.Name.Equals("firstName", StringComparison.OrdinalIgnoreCase));
var lastNameProperty = nameProperty.Properties.First(x => x.Key.Name.Equals("lastName", StringComparison.OrdinalIgnoreCase));
//ASSERT person name
Assert.IsTrue(indexResponse.IsValid);
Assert.AreEqual(1, indices.Count);
Assert.AreEqual("object", nameProperty.Type.Name);
//ASSERT person first name
Assert.AreEqual("keyword", firstNameProperty.Value.Type.Name);
//ASSERT person last name
Assert.AreEqual("keyword", lastNameProperty.Value.Type.Name);
}
finally
{
client.DeleteIndex(index);
}
}
protected override void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
DependencyResolver.Reset();
ValidationServiceMock.VerifyAll();
UnitOfWorkMock.VerifyAll();
DependencyResolverMock.VerifyAll();
}
public void DispatchToKafkaServerTest()
{
//ARRANGE
var documentId = Guid.NewGuid();
var document = new ParentTestClass {
Email = "*****@*****.**", IntField = 10, DateFiled = DateTimeOffset.Now, Child = new ChildClass {
Name = "Child1", ChildEmail = "*****@*****.**", ChildIntField = 100, ChildDateFiled = DateTimeOffset.Now
}
};
document.Child.Parent = document;
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(ParentTestClass).Name, indexId);
var indexContext = new IndexContext(typeof(ParentTestClass), 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);
////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 <ParentTestClass>(documentId)
{
Document = document, IndexContext = indexContext
};
var dispatcher = new KafkaDispatcherConfuence(producerConfigManager);
//ACT
dispatcher.UpsertDocument(context);
//.Wait();
//ASSERT
}
finally
{
}
}
public void CommandHandlerResolverTest_resolve_by_assembly_scanning_no_limit()
{
//ARRANGE
var dependencyResolver = new DependencyResolverMock();
var handlerFactorySettings = new HandlerFactorySettingsMock();
var handlerResolver = new HandlerResolver(dependencyResolver, handlerFactorySettings);
dependencyResolver.RegisterFactory <Action>(t => () => { }, Lifetime.Singleton);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestCommand));
//ASSERT
Assert.IsInstanceOf <TestCommandHandler>(handler.Single());
}
public void EventHandlerResolverTest()
{
//ARRANGE
var dependencyResolver = new DependencyResolverMock();
var handlerFactorySettings = new HandlerFactorySettingsMock();
var handlerResolver = new HandlerResolver(dependencyResolver, handlerFactorySettings);
dependencyResolver.RegisterFactory <Action>(t => () => { }, Lifetime.Singleton);
//ACT
var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestEvent));
//ASSERT
Assert.IsInstanceOf <TestEventHandler>(handler.Single());
}
public void GetIndexState()
{
//ARRANGE
//var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
//create an unique index
var indexName = String.Format("{0}", typeof(EsPersonSearch).Name).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext <ParentTestClass>(indexName);
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
var indexDescriptor = new CreateIndexDescriptor(index).Mappings(map => map.Map <EsPersonSearch>(m => m.AutoMap()));
//ACT
try
{
var template = client.GetIndexTemplate(d => d.Name("personsearch"));
//var documents = client.Search<EsPersonSearch>(s =>
//s.Query(q => q.MatchAll())
//.Index(index));
// var document = client.Search<EsPersonSearch>(s =>
//s.Query(q => q.Match(m =>
// m.Field(f => f.PersonName.LastName)
//.Query("Doe")))
//.Index(index));
//var allIndices = client.GetIndex(Indices.All);
var indexState = indexManager.GetIndexState(indexContext);
var providedName = indexState.Settings["index.provided_name"];
var propertiesMapped = indexState.Mappings.SelectMany(x => x.Value.Properties);
//ASSERT
Assert.AreEqual(indexName, providedName);
}
finally
{
//client.DeleteIndex(index);
}
}
public void GetPropertyMetaData_test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
dependencyResolver.RegisterFactory <QueryClauseBuilder <FieldContext> >(t => new TermClauseBuilder(), Lifetime.Transient);
dependencyResolver.RegisterFactory <QueryClauseBuilder <NestedFieldContext> >(t => new NestedClauseBuilder(), Lifetime.Transient);
//create an unique index
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext <ParentTestClass>(indexName);
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.Properties(p => p.Keyword(d => d.Name(n => n.Email))).AutoMap()));
//ACT
try
{
client.CreateIndex(indexDescriptor);
Thread.Sleep(1000);
//var indexState = client.GetIndex(index);
var emailPropertyMetaData = indexManager.GetPropertyMetaData <ParentTestClass>(indexContext, x => x.Email);
var childPropertyMetaData = indexManager.GetPropertyMetaData <ParentTestClass>(indexContext, x => x.Child);
//ASSERT
Assert.AreEqual("keyword", emailPropertyMetaData.Type.Name);
}
finally
{
client.DeleteIndex(index);
}
}
public void GetIndexState_test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
//create an unique index
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext <ParentTestClass>(indexName);
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.Properties(p => p.Keyword(d => d.Name(n => n.Email))).AutoMap()));
//var index = indexManager.BuildIndexName(indexContext);
//ACT
try
{
client.CreateIndex(indexDescriptor);
//indexManager.BuildIndex(index).Wait();
Thread.Sleep(1000);
var indexState = indexManager.GetIndexState(indexContext);
var providedName = indexState.Settings["index.provided_name"];
var propertiesMapped = indexState.Mappings.SelectMany(x => x.Value.Properties);
//ASSERT
Assert.AreEqual(indexName, providedName);
}
finally
{
client.DeleteIndex(index);
}
}
public void GetNestedPropertyMetaData_test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
//create an unique index
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext <ParentTestClass>(indexName);
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.Properties(p => p.Keyword(d => d.Name(n => n.Email))).AutoMap()));
//ACT
try
{
client.CreateIndex(indexDescriptor);
Thread.Sleep(1000);
//var childPropertyMetaData = indexManager.GetPropertyMetaData<ParentTestClass>(indexContext, x => x.Child.Name);
var childPropertyMetaData = indexManager.GetPropertyMetaData <ParentTestClass>(indexContext, "ParentTestClass.Child.Name");
//ASSERT
Assert.AreEqual("text", childPropertyMetaData.Type.Name);
}
finally
{
client.DeleteIndex(index);
//client.DeleteIndex(Indices.All);
}
}
public void BuildIndexName_name_no_name_provided_test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var clientFactory = SearchClientFactory.GetClientFactory();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext(typeof(ParentTestClass));
//ACT
var index = indexManager.BuildIndexName(indexContext);
//ASSERT
Assert.AreEqual(typeof(ParentTestClass).Name.ToLower(), index.Name);
Assert.AreEqual(typeof(ParentTestClass), index.Type);
}
public void CreateIndex_if_exist_test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
//create an unique index
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext(typeof(ParentTestClass), indexName);
var index = indexManager.BuildIndexName(indexContext);
//ACT
try
{
indexManager.BuildIndex(index).Wait();
Thread.Sleep(1000);
indexManager.BuildIndex(index).Wait();
var indexReqiest = new GetIndexRequest(index);
var indexResponse = client.GetIndex(indexReqiest);
var indices = indexResponse.Indices.ToList();
var first = indices.First();
var providedName = first.Value.Settings["index.provided_name"];
//ASSERT
Assert.IsTrue(indexResponse.IsValid);
Assert.AreEqual(1, indices.Count);
Assert.AreEqual(indexName, providedName);
}
finally
{
client.DeleteIndex(index);
}
}
public void DeletIndex_test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
//create an unique index
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var responseHandler = new ResponseHandler();
var indexManager = new IndexManager(dependencyResolver, clientFactory, responseHandler);
var indexContext = new IndexContext(typeof(ParentTestClass), indexName);
var index = indexManager.BuildIndexName(indexContext);
//ACT
try
{
client.CreateIndex(index);
Thread.Sleep(1000);
var indexReqiest = new GetIndexRequest(index);
var indexResponse = client.GetIndex(indexReqiest);
//delete the index
indexManager.DeleteIndex(indexContext);
var indexResponseAfterDelete = client.GetIndex(indexReqiest);
//ASSERT
Assert.IsTrue(indexResponse.IsValid);
Assert.IsFalse(indexResponseAfterDelete.IsValid);
}
finally
{
client.DeleteIndex(index);
}
}
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
{
}
}
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);
}
}
public void Search_match_term_by_Id_Test()
{
//ARRANGE
var id = Guid.NewGuid();
//set up search client
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
//create index name
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
try
{
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.AutoMap()));
var createIndexRequest = client.CreateIndex(indexDescriptor);
var testClass = new ParentTestClass();
testClass.Children.Add(new ChildClass());
var createDocumentResponse = client.Create(testClass, d => d.Index(index)
.Type(typeof(ParentTestClass)));
Thread.Sleep(1000);
//ACT
//Search
var searchMatchResponse = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Match(m => m.Field(field => field.Id)
.Query(testClass.Id.ToString())))
.Index(index));
var searchTermResponse = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Term(m => m.Field(field => field.Id)
.Value(testClass.Id.ToString())))
.Index(index));
//ASSERT match response
Assert.IsTrue(searchMatchResponse.IsValid);
Assert.AreEqual(1, searchMatchResponse.Documents.Count());
Assert.AreEqual(testClass.Id, searchMatchResponse.Documents.First().Id);
Assert.AreEqual(1, searchMatchResponse.Documents.First().Children.Count());
Assert.AreEqual(testClass.Children.First().Id, searchMatchResponse.Documents.First().Children.First().Id);
//ASSERT term response
Assert.IsTrue(searchTermResponse.IsValid);
Assert.AreEqual(1, searchTermResponse.Documents.Count());
Assert.AreEqual(testClass.Id, searchTermResponse.Documents.First().Id);
Assert.AreEqual(1, searchTermResponse.Documents.First().Children.Count());
Assert.AreEqual(testClass.Children.First().Id, searchTermResponse.Documents.First().Children.First().Id);
}
finally
{
var deleteIndexResult = client.DeleteIndex(index);
}
}
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 RecieveMessageFromKafkaTest()
{
//ARRANGE
var recieved = false;
var documentId = Guid.NewGuid();
var document = new ParentTestClass();
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(ParentTestClass).Name, indexId);
var indexContext = new IndexContext(typeof(ParentTestClass), 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);
dependencyResolver.RegisterFactory <IConfigurationProvider>((t) => new GroupIdProvider(), Lifetime.Transient);
////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<ParentTestClass>(documentId) { Document = document, IndexContext = indexContext };
//var dispatcher = new KafkaDispatcher(producerConfigManager);
//ACT
var topic = typeof(ParentTestClass).Name;
var cancelled = false;
//var time = new Timer(new TimerCallback((_) => cancelled = true), null, 5000, 5000);
var valueSerializer = new BinarySerializer <ParentTestClass>();
var keySerializer = new BinarySerializer <Guid>();
var config = producerConfigManager.GetConfiguration(x => (x.ConfigurationScope & ConfigurationScope.Consumer) == ConfigurationScope.Consumer);
using (var consumer = new Consumer <Guid, ParentTestClass>(config, keySerializer, valueSerializer))
{
var metaData = consumer.GetMetadata(true);
consumer.OnMessage += (_, msg)
=>
{
consumer.CommitAsync(msg).Wait();
recieved = true;
cancelled = true;
};
consumer.OnPartitionEOF += (_, end)
=> Console.WriteLine($"Reached end of topic {end.Topic} partition {end.Partition}.");
consumer.OnError += (_, error) =>
{
Console.WriteLine($"Error: {error}");
cancelled = true;
};
consumer.Subscribe(topic);
var tp = new TopicPartition(topic, 0);
consumer.CommitAsync(new[] { new TopicPartitionOffset(tp, new Offset(15)) });
var possition = consumer.Position(new[] { tp });
var committed = consumer.Committed(new[] { new TopicPartition(topic, 0) }, TimeSpan.FromMilliseconds(5000));
while (!cancelled)
{
consumer.Poll(TimeSpan.FromMilliseconds(100));
}
Assert.True(recieved);
}
}
finally
{
}
}
public void Search_by_email_not_mapped_match_term_comparison_search_Test()
{
//ARRANGE
var id = Guid.NewGuid();
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
//create index name
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
//ACT
try
{
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.AutoMap()
.Properties(prop => prop.Nested <ChildClass>(o =>
o.Name(parent => parent.Child))
)));
var createIndexRequest = client.CreateIndex(indexDescriptor);
var email = "*****@*****.**";
var testClass = new ParentTestClass {
Email = email
};
testClass.Children.Add(new ChildClass());
var createDocumentResponse = client.Create(testClass, d => d.Index(index)
.Type(typeof(ParentTestClass)));
Thread.Sleep(1000);
var indexReqiest = new GetIndexRequest(index);
var indexResponse = client.GetIndex(indexReqiest);
var indices = indexResponse.Indices.ToList();
var first = indices.First();
var mappings = first.Value.Mappings.First()
.Value.Properties.Select(p => new { p.Key.Name, p.Value.Type, PropertyName = p.Value.Name });
//ACT
//Search
var searchResponse = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Match(m => m.Field(g => g.Email)
.Query(email)))
.Index(index));
var searchResponse_partial = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Match(m => m.Field(g => g.Email)
.Query("foreName.lastName")))
.Index(index));
var searchResponse_full_term = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Term(m => m.Field(g => g.Email)
.Value(email)))
.Index(index));
//ASSERT match full search response
Assert.IsTrue(searchResponse.IsValid);
Assert.AreEqual(1, searchResponse.Documents.Count());
Assert.AreEqual(testClass.Id, searchResponse.Documents.First().Id);
Assert.AreEqual(testClass.Email, searchResponse.Documents.First().Email);
//ASSERT partial match search response
Assert.IsTrue(searchResponse_partial.IsValid);
Assert.AreEqual(1, searchResponse_partial.Documents.Count());
Assert.AreEqual(testClass.Id, searchResponse_partial.Documents.First().Id);
Assert.AreEqual(testClass.Email, searchResponse_partial.Documents.First().Email);
//ASSERT full term search response
Assert.IsTrue(searchResponse_full_term.IsValid);
Assert.AreEqual(0, searchResponse_full_term.Documents.Count());
}
finally
{
var deleteIndexResult = client.DeleteIndex(index);
}
}
public void Bool_must_query_test()
{
//ARRANGE
var id = Guid.NewGuid();
//set up search client
var dependencyResolver = new DependencyResolverMock();
var client = SearchClientFactory.GetClient();
//create index name
var indexName = String.Format("{0}_{1}", typeof(ParentTestClass).Name, id).ToLower();
var index = new IndexName {
Name = indexName, Type = typeof(ParentTestClass)
};
try
{
var indexDescriptor = new CreateIndexDescriptor(index)
.Mappings(map => map.Map <ParentTestClass>(m =>
m.Properties(p => p.Keyword(d => d.Name(n => n.Email)))));
//m.AutoMap()));
var createIndexRequest = client.CreateIndex(indexDescriptor);
var testClass = new ParentTestClass {
IntField = 0, Email = "Text0"
};
testClass.Children.Add(new ChildClass());
var testClass1 = new ParentTestClass {
IntField = 1, Email = "Text1"
};
testClass1.Children.Add(new ChildClass());
var testClass2 = new ParentTestClass {
IntField = 2, Email = "Text2"
};
testClass2.Children.Add(new ChildClass());
var testClass3 = new ParentTestClass {
IntField = 3, Email = "Text3"
};
testClass2.Children.Add(new ChildClass());
var createDocumentResponse = client.Create(testClass, d => d.Index(index)
.Type(typeof(ParentTestClass)));
var createDocumentResponse1 = client.Create(testClass1, d => d.Index(index)
.Type(typeof(ParentTestClass)));
var createDocumentResponse2 = client.Create(testClass2, d => d.Index(index)
.Type(typeof(ParentTestClass)));
var createDocumentResponse3 = client.Create(testClass3, d => d.Index(index)
.Type(typeof(ParentTestClass)));
Thread.Sleep(1000);
var i = client.GetIndex(new GetIndexRequest(index));
//ACT
//Search
var searchMatchResponse = client
.Search <ParentTestClass>(s =>
s.Query(q =>
q.Bool(b =>
b.Should(must =>
must.Term(term =>
term.Field(field => field.Email)
.Value("Text1"))
, must =>
must.Term(term =>
term.Field(f => f.Email).
Value("Text2"))
, must =>
must.Term(term =>
term.Field(f => f.Email).
Value("Text3")))
.Filter(filter =>
filter.Range(range =>
range.Field(field => field.IntField)
.GreaterThan(1)
.LessThan(10)))
)
)
.Index(index));
//ASSERT match response
Assert.IsTrue(searchMatchResponse.IsValid);
Assert.AreEqual(1, searchMatchResponse.Documents.Count());
//Assert.AreEqual(testClass.Id, searchMatchResponse.Documents.First().Id);
//Assert.AreEqual(1, searchMatchResponse.Documents.First().Children.Count());
//Assert.AreEqual(testClass.Children.First().Id, searchMatchResponse.Documents.First().Children.First().Id);
//ASSERT term response
//Assert.IsTrue(searchTermResponse.IsValid);
//Assert.AreEqual(1, searchTermResponse.Documents.Count());
//Assert.AreEqual(testClass.Id, searchTermResponse.Documents.First().Id);
//Assert.AreEqual(1, searchTermResponse.Documents.First().Children.Count());
//Assert.AreEqual(testClass.Children.First().Id, searchTermResponse.Documents.First().Children.First().Id);
}
finally
{
var deleteIndexResult = client.DeleteIndex(index);
}
}
public void CreatePersonSearchDocumentTest()
{
//ARRANGE
//set up a person
var dependencyResolver = new DependencyResolverMock();
var id = Guid.NewGuid();
var client = SearchClientFactory.GetClient();
var clientFactory = SearchClientFactory.GetClientFactory();
SearchClientFactory.RegisterDependencies(dependencyResolver);
//delete person index
var index = new IndexName {
Name = String.Format("{0}_{1}", typeof(EsPersonSearch).Name, id).ToLower(), Type = typeof(EsPersonSearch)
};
var deleteIndexResult = client.DeleteIndex(index);
//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);
var builder = new AddPersonContextBuilder();
var personId = Guid.NewGuid();
var ev = new NewPersonAdded(
new AggregateId(personId),
new CQRS.CorrelationId(personId),
null,
1,
1,
1,
new PersonName
{
FirstName = "John",
LastName = "Doe"
},
null);
var context = builder.BuildContext(ev);
try
{
//create person document
documentclient.UpsertDocument(context);
Thread.Sleep(1000);
var document = client.Get <EsPersonSearch>(personId, d => d.Index(index));
var personName = new PersonName
{
FirstName = "John1",
LastName = "Doe1"
};
var builder1 = new AddPossitionContexttBuilder();
var ev1 = new NewPositionAdded(
new AggregateId(personId),
null,
new CQRS.CorrelationId(personId),
personId,
Guid.NewGuid(),
null,
1,
1,
1,
personName,
"TestOrganisation");
var newPossitionAdded = builder1.BuildContext(ev1);
context = builder1.BuildContext(ev1);
documentclient.UpsertDocument(context);
Thread.Sleep(1000);
document = client.Get <EsPersonSearch>(personId, d => d.Index(index));
var builder2 = new PersonNameEditedContextBuilder();
var ev2 = new NameEdited(
new AggregateId(personId),
1,
new CQRS.CorrelationId(personId),
null,
personName,
1);
context = builder2.BuildContext(ev2);
documentclient.UpsertDocument(context);
Thread.Sleep(1000);
document = client.Get <EsPersonSearch>(personId, d => d.Index(index));
}
finally
{
client.DeleteIndex(index);
}
}
