public async Task SortByNumberAsync() { await _employeeRepository.AddAsync(new List <Employee> { EmployeeGenerator.Generate(age: 19), EmployeeGenerator.Generate(age: 9), EmployeeGenerator.Generate(age: 119), EmployeeGenerator.Generate(age: 20) }, o => o.ImmediateConsistency()); var searchRepository = (ISearchableReadOnlyRepository <Employee>)_employeeRepository; var results = await searchRepository.SearchAsync(null, sort : "age"); var employees = results.Documents.ToArray(); Assert.Equal(4, employees.Length); Assert.Equal(9, employees[0].Age); Assert.Equal(19, employees[1].Age); Assert.Equal(20, employees[2].Age); Assert.Equal(119, employees[3].Age); results = await searchRepository.SearchAsync(null, sort : "-age"); employees = results.Documents.ToArray(); Assert.Equal(4, employees.Length); Assert.Equal(119, employees[0].Age); Assert.Equal(20, employees[1].Age); Assert.Equal(19, employees[2].Age); Assert.Equal(9, employees[3].Age); }
public async Task SearchByQueryWithIncludesAnAliases() { var employees = EmployeeGenerator.GenerateEmployees(age: 10); await _employeeRepository.AddAsync(employees); await _client.RefreshAsync(); var result = await _employeeRepository.SearchAsync(null, null, "@include:myquery"); Assert.Equal(10, result.Total); }
public async Task AddAsync() { var employee = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(name: " BLAKE ")); Assert.NotNull(employee?.Id); var result = await _employeeRepository.GetByIdAsync(employee.Id); Assert.Equal("blake", result.Name); }
public async Task CanCacheFindResultAsync() { var employee = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 20), o => o.ImmediateConsistency()); var employees = await _employeeRepository.GetAllByAgeAsync(20); Assert.Equal(1, employees.Documents.Count); string json = JsonConvert.SerializeObject(employees); var results = JsonConvert.DeserializeObject <FindResults <Employee> >(json); Assert.NotNull(results); Assert.Equal(1, results.Documents.Count); }
public async Task HandleFailureInReindexScriptAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version22Index = new VersionedEmployeeIndex(_configuration, 22) { DiscardIndexesOnReindex = false }; await version22Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); IEmployeeRepository version1Repository = new EmployeeRepository(_configuration); var utcNow = SystemClock.UtcNow; var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version22Index.DeleteAsync().GetAwaiter().GetResult())) { await version22Index.ConfigureAsync(); await version22Index.ReindexAsync(); var aliasResponse = await _client.Indices.GetAliasAsync(version1Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key); } } }
public async Task CanCacheFindResult() { var employee = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 20)); await _client.RefreshAsync(); var employees = await _employeeRepository.GetAllByAgeAsync(20); Assert.Equal(1, employees.Documents.Count); var json = JsonConvert.SerializeObject(employees); var results = JsonConvert.DeserializeObject <FindResults <Employee> >(json); Assert.NotNull(results); Assert.Equal(1, results.Documents.Count); }
public async Task CanReindexTimeSeriesIndexWithCorrectMappingsAsync() { var version1Index = new DailyEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new DailyEmployeeIndex(_configuration, 2) { DiscardIndexesOnReindex = false }; await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); IEmployeeRepository version1Repository = new EmployeeRepository(version1Index); var utcNow = SystemClock.UtcNow; var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); await version2Index.ReindexAsync(); var existsResponse = await _client.Indices.ExistsAsync(version1Index.GetVersionedIndex(utcNow, 1)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); var indexV1 = version1Index.GetVersionedIndex(utcNow, 1); var mappingResponse = await _client.Indices.GetMappingAsync <Employee>(m => m.Index(indexV1)); _logger.LogRequest(mappingResponse); Assert.True(mappingResponse.IsValid); var mappingsV1 = mappingResponse.Indices[indexV1]; Assert.NotNull(mappingsV1); string version1Mappings = ToJson(mappingsV1); var indexV2 = version2Index.GetVersionedIndex(utcNow, 2); existsResponse = await _client.Indices.ExistsAsync(indexV2); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); mappingResponse = await _client.Indices.GetMappingAsync <Employee>(m => m.Index(indexV2)); _logger.LogRequest(mappingResponse); Assert.True(mappingResponse.IsValid); var mappingsV2 = mappingResponse.Indices[indexV2]; Assert.NotNull(mappingsV2); string version2Mappings = ToJson(mappingsV2); Assert.Equal(version1Mappings, version2Mappings); } } }
public async Task CanReindexVersionedIndexWithCorrectMappingsAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2) { DiscardIndexesOnReindex = false }; await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); var version1Repository = new EmployeeRepository(version1Index.Employee); var utcNow = SystemClock.UtcNow; var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); await version2Index.ReindexAsync(); var existsResponse = await _client.IndexExistsAsync(version1Index.VersionedName); _logger.LogTrace(existsResponse.GetRequest()); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); var mappingResponse = await _client.GetMappingAsync <Employee>(m => m.Index(version1Index.VersionedName)); _logger.LogTrace(mappingResponse.GetRequest()); Assert.True(mappingResponse.IsValid); Assert.NotNull(mappingResponse.Mappings); existsResponse = await _client.IndexExistsAsync(version2Index.VersionedName); _logger.LogTrace(existsResponse.GetRequest()); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); string version1Mappings = ToJson(mappingResponse.Mappings); mappingResponse = await _client.GetMappingAsync <Employee>(m => m.Index(version1Index.VersionedName)); _logger.LogTrace(mappingResponse.GetRequest()); Assert.True(mappingResponse.IsValid); Assert.NotNull(mappingResponse.Mappings); Assert.Equal(version1Mappings, ToJson(mappingResponse.Mappings).Replace("-v2", "-v1")); } } }
public async Task GetNestedAliasedNumberAggregationsWithFilterAsync() { await _employeeRepository.AddAsync(new Employee { Name = "Blake", Age = 30, Data = new Dictionary <string, object> { { "@user_meta", new { twitter_id = "blaken", twitter_followers = 1000 } } } }, o => o.ImmediateConsistency()); const string aggregations = "min:followers max:followers avg:followers sum:followers cardinality:twitter"; var result = await _employeeRepository.GetCountByQueryAsync(q => q.AggregationsExpression(aggregations)); Assert.Equal(1, result.Total); Assert.Equal(5, result.Aggregations.Count); Assert.Equal(1000, result.Aggregations.Min("min_followers").Value); Assert.Equal(1000, result.Aggregations.Min("max_followers").Value); Assert.Equal(1000, result.Aggregations.Average("avg_followers").Value.GetValueOrDefault()); Assert.Equal(1000, result.Aggregations.Sum("sum_followers").Value); Assert.Equal(1, result.Aggregations.Cardinality("cardinality_twitter").Value); }
public async Task CanReindexSameIndexAsync() { var index = new EmployeeIndex(_configuration); await index.DeleteAsync(); using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) { await index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(index.Name)).Exists); IEmployeeRepository repository = new EmployeeRepository(_configuration); var employee = await repository.AddAsync(EmployeeGenerator.Default, o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); var countResponse = await _client.CountAsync <Employee>(); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); var mappingResponse = await _client.Indices.GetMappingAsync <Employee>(); _logger.LogRequest(mappingResponse); Assert.True(mappingResponse.IsValid); Assert.NotNull(mappingResponse.GetMappingFor(index.Name)); var newIndex = new EmployeeIndexWithYearsEmployed(_configuration); await newIndex.ReindexAsync(); countResponse = await _client.CountAsync <Employee>(); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); string version1Mappings = ToJson(mappingResponse.GetMappingFor <Employee>()); mappingResponse = await _client.Indices.GetMappingAsync <Employee>(); _logger.LogRequest(mappingResponse); Assert.True(mappingResponse.IsValid); Assert.NotNull(mappingResponse.GetMappingFor <Employee>()); Assert.NotEqual(version1Mappings, ToJson(mappingResponse.GetMappingFor <Employee>())); } }
public async Task CanCreateMonthlyAliasesAsync(DateTime utcNow) { using (TestSystemClock.Install()) { SystemClock.Test.SetFixedTime(utcNow); var index = new MonthlyEmployeeIndex(_configuration, 1); await index.DeleteAsync(); using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) { await index.ConfigureAsync(); var repository = new EmployeeRepository(index.Employee); for (int i = 0; i < 4; i++) { var employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow.SubtractMonths(i))); Assert.NotNull(employee?.Id); Assert.Equal(1, await index.GetCurrentVersionAsync()); var existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.Trace(() => existsResponse.GetRequest()); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); var aliasesResponse = await _client.GetAliasAsync(a => a.Index(index.GetIndex(employee.CreatedUtc))); _logger.Trace(() => aliasesResponse.GetRequest()); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); var aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeMonthlyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); } } } }
public async Task CanCreateDailyAliasesAsync(DateTime utcNow) { using (TestSystemClock.Install()) { TestSystemClock.SetFrozenTime(utcNow); var index = new DailyEmployeeIndex(_configuration, 1); await index.DeleteAsync(); using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) { await index.ConfigureAsync(); IEmployeeRepository repository = new EmployeeRepository(index); for (int i = 0; i < 35; i += 5) { var employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow.SubtractDays(i))); Assert.NotNull(employee?.Id); Assert.Equal(1, await index.GetCurrentVersionAsync()); var existsResponse = await _client.Indices.ExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); var aliasesResponse = await _client.Indices.GetAliasAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); var aliases = aliasesResponse.Indices.Values.Single().Aliases.Select(s => s.Key).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeDailyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); } } } }
public async Task CanReindexVersionedIndexWithDataInBothIndexesAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); IEmployeeRepository version1Repository = new EmployeeRepository(_configuration); var employee = await version1Repository.AddAsync(EmployeeGenerator.Default, o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version2Index.VersionedName)).Exists); // swap the alias so we write to v1 and v2 and try to reindex. await _client.Indices.BulkAliasAsync(x => x .Remove(a => a.Alias(version1Index.Name).Index(version1Index.VersionedName)) .Add(a => a.Alias(version2Index.Name).Index(version2Index.VersionedName))); IEmployeeRepository version2Repository = new EmployeeRepository(_configuration); await version2Repository.AddAsync(EmployeeGenerator.Generate(), o => o.ImmediateConsistency()); var countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); // swap back the alias await _client.Indices.BulkAliasAsync(x => x .Remove(a => a.Alias(version2Index.Name).Index(version2Index.VersionedName)) .Add(a => a.Alias(version1Index.Name).Index(version1Index.VersionedName))); Assert.Equal(1, await version2Index.GetCurrentVersionAsync()); // alias should still point to the old version until reindex var aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key); await version2Index.ReindexAsync(); aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version2Index.VersionedName, aliasResponse.Indices.First().Key); Assert.Equal(2, await version1Index.GetCurrentVersionAsync()); Assert.Equal(2, await version2Index.GetCurrentVersionAsync()); await _client.Indices.RefreshAsync(Indices.All); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(2, countResponse.Count); Assert.False((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); } } }
public async Task CanQueryByDeleted() { var employee1 = EmployeeGenerator.Default; employee1.IsDeleted = true; employee1 = await _employeeRepository.AddAsync(employee1); Assert.NotNull(employee1?.Id); await _employeeRepository.AddAsync(EmployeeGenerator.Generate()); await _client.RefreshAsync(); var allEmployees = await _employeeRepository.QueryAsync(new MyAppQuery().IncludeDeleted()); Assert.Equal(2, allEmployees.Total); var onlyDeleted = await _employeeRepository.QueryAsync(new MyAppQuery().IncludeOnlyDeleted()); Assert.Equal(1, onlyDeleted.Total); Assert.Equal(employee1.Id, onlyDeleted.Documents.First().Id); var nonDeletedEmployees = await _employeeRepository.QueryAsync(new MyAppQuery().IncludeDeleted(false)); Assert.Equal(1, nonDeletedEmployees.Total); Assert.NotEqual(employee1.Id, nonDeletedEmployees.Documents.First().Id); }
public async Task CanReindexVersionedIndexWithReindexScriptAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version20Index = new VersionedEmployeeIndex(_configuration, 20) { DiscardIndexesOnReindex = false }; await version20Index.DeleteAsync(); var version21Index = new VersionedEmployeeIndex(_configuration, 21) { DiscardIndexesOnReindex = false }; await version21Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); IEmployeeRepository version1Repository = new EmployeeRepository(version1Index); var utcNow = SystemClock.UtcNow; var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version20Index.DeleteAsync().GetAwaiter().GetResult())) { await version20Index.ConfigureAsync(); await version20Index.ReindexAsync(); IEmployeeRepository version20Repository = new EmployeeRepository(version20Index); var result = await version20Repository.GetByIdAsync(employee.Id); Assert.Equal("scripted", result.CompanyName); using (new DisposableAction(() => version21Index.DeleteAsync().GetAwaiter().GetResult())) { await version21Index.ConfigureAsync(); await version21Index.ReindexAsync(); IEmployeeRepository version21Repository = new EmployeeRepository(version21Index); result = await version21Repository.GetByIdAsync(employee.Id); Assert.Equal("typed script", result.CompanyName); } } } using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); IEmployeeRepository version1Repository = new EmployeeRepository(version1Index); var utcNow = SystemClock.UtcNow; var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version21Index.DeleteAsync().GetAwaiter().GetResult())) { await version21Index.ConfigureAsync(); await version21Index.ReindexAsync(); IEmployeeRepository version21Repository = new EmployeeRepository(version21Index); var result = await version21Repository.GetByIdAsync(employee.Id); Assert.Equal("typed script", result.CompanyName); } } }
public async Task CanReindexVersionedIndexAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); var indexes = _client.GetIndicesPointingToAlias(version1Index.Name); Assert.Single(indexes); var aliasResponse = await _client.Indices.GetAliasAsync(version1Index.Name); _logger.LogRequest(aliasResponse); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key); IEmployeeRepository version1Repository = new EmployeeRepository(_configuration); var employee = await version1Repository.AddAsync(EmployeeGenerator.Default, o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); var countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.Name)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version2Index.VersionedName)).Exists); // Make sure we can write to the index still. Should go to the old index until after the reindex is complete. IEmployeeRepository version2Repository = new EmployeeRepository(_configuration); await version2Repository.AddAsync(EmployeeGenerator.Generate(), o => o.ImmediateConsistency()); countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(2, countResponse.Count); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(0, countResponse.Count); Assert.Equal(1, await version2Index.GetCurrentVersionAsync()); // alias should still point to the old version until reindex aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key); await version2Index.ReindexAsync(); aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version2Index.VersionedName, aliasResponse.Indices.First().Key); Assert.Equal(2, await version1Index.GetCurrentVersionAsync()); Assert.Equal(2, await version2Index.GetCurrentVersionAsync()); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(2, countResponse.Count); Assert.False((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); employee = await version2Repository.AddAsync(EmployeeGenerator.Default, o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.Name)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(3, countResponse.Count); } } }
public async Task MaintainMonthlyIndexesAsync() { using (TestSystemClock.Install()) { SystemClock.Test.SetFixedTime(new DateTime(2016, 8, 31, 0, 0, 0, DateTimeKind.Utc)); var index = new MonthlyEmployeeIndex(_configuration, 1) { MaxIndexAge = SystemClock.UtcNow.EndOfMonth() - SystemClock.UtcNow.SubtractMonths(4).StartOfMonth() }; await index.DeleteAsync(); var utcNow = SystemClock.UtcNow; using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) { await index.ConfigureAsync(); var repository = new EmployeeRepository(index.Employee); for (int i = 0; i < 4; i++) { var created = utcNow.SubtractMonths(i); var employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: created)); Assert.NotNull(employee?.Id); Assert.Equal(1, await index.GetCurrentVersionAsync()); var existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogTraceRequest(existsResponse); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); var aliasesResponse = await _client.GetAliasAsync(a => a.Index(index.GetIndex(employee.CreatedUtc))); _logger.LogTraceRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); var aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeMonthlyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); } await index.MaintainAsync(); for (int i = 0; i < 4; i++) { var created = utcNow.SubtractMonths(i); var employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: created)); Assert.NotNull(employee?.Id); Assert.Equal(1, await index.GetCurrentVersionAsync()); var existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogTraceRequest(existsResponse); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); var aliasesResponse = await _client.GetAliasAsync(a => a.Index(index.GetIndex(employee.CreatedUtc))); _logger.LogTraceRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); var aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeMonthlyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); } } } }
public async Task CanResumeReindexAsync() { const int numberOfEmployeesToCreate = 2000; var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); IEmployeeRepository version1Repository = new EmployeeRepository(_configuration); await version1Repository.AddAsync(EmployeeGenerator.GenerateEmployees(numberOfEmployeesToCreate), o => o.ImmediateConsistency()); var countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.Name)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(numberOfEmployeesToCreate, countResponse.Count); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version2Index.VersionedName)).Exists); // Throw error before second repass. await Assert.ThrowsAsync <ApplicationException>(async() => await version2Index.ReindexAsync((progress, message) => { _logger.LogInformation("Reindex Progress {0}%: {1}", progress, message); if (progress == 91) { throw new ApplicationException("Random Error"); } return(Task.CompletedTask); })); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); // Add a document and ensure it resumes from this document. await version1Repository.AddAsync(EmployeeGenerator.Generate(ObjectId.GenerateNewId(SystemClock.UtcNow.AddMinutes(1)).ToString()), o => o.ImmediateConsistency()); await version2Index.ReindexAsync(); var aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version2Index.VersionedName, aliasResponse.Indices.First().Key); Assert.Equal(2, await version1Index.GetCurrentVersionAsync()); Assert.Equal(2, await version2Index.GetCurrentVersionAsync()); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(numberOfEmployeesToCreate + 1, countResponse.Count); Assert.False((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); } } }
public async Task AddAsync() { var employee = EmployeeGenerator.Default; Assert.Equal(0, employee.Version); employee = await _employeeRepository.AddAsync(employee); Assert.NotNull(employee?.Id); Assert.Equal(1, employee.Version); var employee2 = await _employeeRepository.GetByIdAsync(employee.Id); Assert.Equal(employee, employee2); }
public async Task MonthlyAliasMaxAgeAsync(DateTime utcNow) { using (TestSystemClock.Install()) { TestSystemClock.SetFrozenTime(utcNow); var index = new MonthlyEmployeeIndex(_configuration, 1) { MaxIndexAge = TimeSpan.FromDays(90) }; await index.DeleteAsync(); using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) { await index.ConfigureAsync(); IEmployeeRepository repository = new EmployeeRepository(index); var employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); var existsResponse = await _client.Indices.ExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); var aliasesResponse = await _client.Indices.GetAliasAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); var aliases = aliasesResponse.Indices.Values.Single().Aliases.Select(s => s.Key).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeMonthlyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow.SubtractDays(2)), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); existsResponse = await _client.Indices.ExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); aliasesResponse = await _client.Indices.GetAliasAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); aliases = aliasesResponse.Indices.Values.Single().Aliases.Select(s => s.Key).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeMonthlyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow.SubtractDays(35)), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); existsResponse = await _client.Indices.ExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); aliasesResponse = await _client.Indices.GetAliasAsync(index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); aliases = aliasesResponse.Indices.Values.Single().Aliases.Select(s => s.Key).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeMonthlyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); } } }
public async Task DailyAliasMaxAgeAsync(DateTime utcNow) { using (TestSystemClock.Install()) { SystemClock.Test.SetFixedTime(utcNow); var index = new DailyEmployeeIndex(_configuration, 1) { MaxIndexAge = TimeSpan.FromDays(45) }; await index.DeleteAsync(); using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) { await index.ConfigureAsync(); var version1Repository = new EmployeeRepository(index.Employee); var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); var existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.Trace(() => existsResponse.GetRequest()); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); var aliasesResponse = await _client.GetAliasAsync(a => a.Index(index.GetIndex(employee.CreatedUtc))); _logger.Trace(() => aliasesResponse.GetRequest()); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); var aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeDailyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow.SubtractDays(2)), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.Trace(() => existsResponse.GetRequest()); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); aliasesResponse = await _client.GetAliasAsync(a => a.Index(index.GetIndex(employee.CreatedUtc))); _logger.Trace(() => aliasesResponse.GetRequest()); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeDailyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow.SubtractDays(35)), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc)); _logger.Trace(() => existsResponse.GetRequest()); Assert.True(existsResponse.IsValid); Assert.True(existsResponse.Exists); aliasesResponse = await _client.GetAliasAsync(a => a.Index(index.GetIndex(employee.CreatedUtc))); _logger.Trace(() => aliasesResponse.GetRequest()); Assert.True(aliasesResponse.IsValid); Assert.Equal(1, aliasesResponse.Indices.Count); aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeDailyAliases(index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); } } }
public async Task CanReindexVersionedIndexWithUpdatedDocsAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); Assert.True(_client.IndexExists(version1Index.VersionedName).Exists); var repository = new EmployeeRepository(version1Index.Employee); var employee = await repository.AddAsync(EmployeeGenerator.Default, o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); Assert.True(_client.IndexExists(version2Index.VersionedName).Exists); Assert.Equal(1, await version2Index.GetCurrentVersionAsync()); // alias should still point to the old version until reindex var aliasResponse = await _client.GetAliasAsync(descriptor => descriptor.Name(version2Index.Name)); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key); var countdown = new AsyncCountdownEvent(1); var reindexTask = version2Index.ReindexAsync((progress, message) => { _logger.LogInformation($"Reindex Progress {progress}%: {message}"); if (progress == 91) { countdown.Signal(); SystemClock.Sleep(1000); } return(Task.CompletedTask); }); // Wait until the first reindex pass is done. await countdown.WaitAsync(); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: SystemClock.UtcNow)); employee.Name = "Updated"; await repository.SaveAsync(employee); // Resume after everythings been indexed. await reindexTask; aliasResponse = await _client.GetAliasAsync(descriptor => descriptor.Name(version2Index.Name)); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version2Index.VersionedName, aliasResponse.Indices.First().Key); Assert.Equal(2, await version1Index.GetCurrentVersionAsync()); Assert.Equal(2, await version2Index.GetCurrentVersionAsync()); await _client.RefreshAsync(Indices.All); var countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogTrace(countResponse.GetRequest()); Assert.True(countResponse.IsValid); Assert.Equal(2, countResponse.Count); var result = await repository.GetByIdAsync(employee.Id); Assert.Equal(ToJson(employee), ToJson(result)); Assert.False((await _client.IndexExistsAsync(version1Index.VersionedName)).Exists); } } }
public async Task CanReindexVersionedIndexWithDeletedDocsAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); IEmployeeRepository repository = new EmployeeRepository(_configuration); var employee = await repository.AddAsync(EmployeeGenerator.Default, o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version2Index.VersionedName)).Exists); Assert.Equal(1, await version2Index.GetCurrentVersionAsync()); // alias should still point to the old version until reindex var aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); _logger.LogRequest(aliasResponse); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key); var countdown = new AsyncCountdownEvent(1); var reindexTask = version2Index.ReindexAsync(async(progress, message) => { _logger.LogInformation($"Reindex Progress {progress}%: {message}"); if (progress == 91) { countdown.Signal(); await Task.Delay(1000); } }); // Wait until the first reindex pass is done. await countdown.WaitAsync(); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); await repository.RemoveAllAsync(o => o.ImmediateConsistency()); // Resume after everythings been indexed. await reindexTask; aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); _logger.LogRequest(aliasResponse); Assert.True(aliasResponse.IsValid, aliasResponse.GetErrorMessage()); Assert.Equal(1, aliasResponse.Indices.Count); Assert.Equal(version2Index.VersionedName, aliasResponse.Indices.First().Key); Assert.Equal(2, await version1Index.GetCurrentVersionAsync()); Assert.Equal(2, await version2Index.GetCurrentVersionAsync()); var countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.ApiCall.HttpStatusCode == 404, countResponse.GetErrorMessage()); Assert.Equal(0, countResponse.Count); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid, countResponse.GetErrorMessage()); Assert.Equal(1, countResponse.Count); Assert.Equal(employee, await repository.GetByIdAsync(employee.Id)); Assert.False((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); } } }
public async Task CanReindexTimeSeriesIndexAsync() { var version1Index = new DailyEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new DailyEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); IEmployeeRepository version1Repository = new EmployeeRepository(version1Index); var utcNow = SystemClock.UtcNow; var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); Assert.NotNull(employee?.Id); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); var aliasCountResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.Name)); _logger.LogRequest(aliasCountResponse); Assert.True(aliasCountResponse.IsValid); Assert.Equal(1, aliasCountResponse.Count); var indexCountResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.GetIndex(utcNow))); _logger.LogRequest(indexCountResponse); Assert.True(indexCountResponse.IsValid); Assert.Equal(1, indexCountResponse.Count); indexCountResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.GetVersionedIndex(utcNow, 1))); _logger.LogRequest(indexCountResponse); Assert.True(indexCountResponse.IsValid); Assert.Equal(1, indexCountResponse.Count); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { await version2Index.ConfigureAsync(); Assert.Equal(1, await version2Index.GetCurrentVersionAsync()); IEmployeeRepository version2Repository = new EmployeeRepository(version2Index); // Make sure we write to the old index. await version2Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow), o => o.ImmediateConsistency()); aliasCountResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.Name)); _logger.LogRequest(aliasCountResponse); Assert.True(aliasCountResponse.IsValid); Assert.Equal(2, aliasCountResponse.Count); indexCountResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.GetVersionedIndex(utcNow, 1))); _logger.LogRequest(indexCountResponse); Assert.True(indexCountResponse.IsValid); Assert.Equal(2, indexCountResponse.Count); var existsResponse = await _client.Indices.ExistsAsync(version2Index.GetVersionedIndex(utcNow, 2)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.False(existsResponse.Exists); // alias should still point to the old version until reindex var aliasesResponse = await _client.Indices.GetAliasAsync(version1Index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(version1Index.GetVersionedIndex(employee.CreatedUtc, 1), aliasesResponse.Indices.Single().Key); var aliases = aliasesResponse.Indices.Values.Single().Aliases.Select(s => s.Key).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeDailyAliases(version1Index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); await version2Index.ReindexAsync(); Assert.Equal(2, await version1Index.GetCurrentVersionAsync()); Assert.Equal(2, await version2Index.GetCurrentVersionAsync()); aliasesResponse = await _client.Indices.GetAliasAsync(version1Index.GetIndex(employee.CreatedUtc)); _logger.LogRequest(aliasesResponse); Assert.True(aliasesResponse.IsValid); Assert.Equal(version1Index.GetVersionedIndex(employee.CreatedUtc, 2), aliasesResponse.Indices.Single().Key); aliases = aliasesResponse.Indices.Values.Single().Aliases.Select(s => s.Key).ToList(); aliases.Sort(); Assert.Equal(GetExpectedEmployeeDailyAliases(version1Index, utcNow, employee.CreatedUtc), String.Join(", ", aliases)); existsResponse = await _client.Indices.ExistsAsync(version1Index.GetVersionedIndex(utcNow, 1)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.False(existsResponse.Exists); existsResponse = await _client.Indices.ExistsAsync(version2Index.GetVersionedIndex(utcNow, 2)); _logger.LogRequest(existsResponse); Assert.True(existsResponse.ApiCall.Success); Assert.True(existsResponse.Exists); } } }
public async Task CanHandleReindexFailureAsync() { var version1Index = new VersionedEmployeeIndex(_configuration, 1); await version1Index.DeleteAsync(); var version2Index = new VersionedEmployeeIndex(_configuration, 2); await version2Index.DeleteAsync(); using (new DisposableAction(() => version1Index.DeleteAsync().GetAwaiter().GetResult())) { await version1Index.ConfigureAsync(); Assert.True((await _client.Indices.ExistsAsync(version1Index.VersionedName)).Exists); IEmployeeRepository version1Repository = new EmployeeRepository(_configuration); await version1Repository.AddAsync(EmployeeGenerator.Generate(), o => o.ImmediateConsistency()); var countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.Name)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) { //Create invalid mappings var response = await _client.Indices.CreateAsync(version2Index.VersionedName, d => d.Map <Employee>(map => map .Dynamic(false) .Properties(p => p .Number(f => f.Name(e => e.Id)) ))); _logger.LogRequest(response); Assert.True((await _client.Indices.ExistsAsync(version2Index.VersionedName)).Exists); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); await version2Index.ReindexAsync(); await version2Index.Configuration.Client.Indices.RefreshAsync(Indices.All); var aliasResponse = await _client.Indices.GetAliasAsync(version2Index.Name); Assert.True(aliasResponse.IsValid); Assert.Equal(1, aliasResponse.Indices.Count); Assert.True(aliasResponse.Indices.ContainsKey(version1Index.VersionedName)); var indexResponse = await _client.Cat.IndicesAsync(d => d.Index(Indices.Index("employees-*"))); Assert.NotNull(indexResponse.Records.FirstOrDefault(r => r.Index == version1Index.VersionedName)); Assert.NotNull(indexResponse.Records.FirstOrDefault(r => r.Index == version2Index.VersionedName)); Assert.NotNull(indexResponse.Records.FirstOrDefault(r => r.Index == $"{version2Index.VersionedName}-error")); Assert.Equal(1, await version1Index.GetCurrentVersionAsync()); Assert.Equal(1, await version2Index.GetCurrentVersionAsync()); countResponse = await _client.CountAsync <Employee>(d => d.Index(version1Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); countResponse = await _client.CountAsync <Employee>(d => d.Index(version2Index.VersionedName)); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(0, countResponse.Count); countResponse = await _client.CountAsync <object>(d => d.Index($"{version2Index.VersionedName}-error")); _logger.LogRequest(countResponse); Assert.True(countResponse.IsValid); Assert.Equal(1, countResponse.Count); } } }
public async Task CanQueryByDeleted() { var employee1 = EmployeeGenerator.Default; employee1.IsDeleted = true; employee1 = await _employeeRepository.AddAsync(employee1, o => o.ImmediateConsistency()); Assert.NotNull(employee1?.Id); await _employeeRepository.AddAsync(EmployeeGenerator.Generate(), o => o.ImmediateConsistency()); var allEmployees = await _employeeRepository.GetByQueryAsync(q => q.SoftDeleteMode(SoftDeleteQueryMode.All)); Assert.Equal(2, allEmployees.Total); var onlyDeleted = await _employeeRepository.GetByQueryAsync(q => q.SoftDeleteMode(SoftDeleteQueryMode.DeletedOnly)); Assert.Equal(1, onlyDeleted.Total); Assert.Equal(employee1.Id, onlyDeleted.Documents.First().Id); var nonDeletedEmployees = await _employeeRepository.GetByQueryAsync(q => q.SoftDeleteMode(SoftDeleteQueryMode.ActiveOnly)); Assert.Equal(1, nonDeletedEmployees.Total); Assert.NotEqual(employee1.Id, nonDeletedEmployees.Documents.First().Id); }
public async Task GetByAgeAsync() { var employee19 = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 19), o => o.ImmediateConsistency()); var employee20 = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 20), o => o.ImmediateConsistency()); var results = await _employeeRepository.GetAllByAgeAsync(employee19.Age); Assert.Equal(1, results.Total); Assert.Equal(employee19, results.Documents.First()); results = await _employeeRepository.GetAllByAgeAsync(employee20.Age); Assert.Equal(1, results.Total); Assert.Equal(employee20, results.Documents.First()); }
public async Task AddWithDefaultGeneratedIdAsync() { await RemoveDataAsync(); var employee = await _repository.AddAsync(EmployeeGenerator.Default); Assert.NotNull(employee?.Id); Assert.Equal(EmployeeGenerator.Default.Name, employee.Name); Assert.Equal(EmployeeGenerator.Default.Age, employee.Age); Assert.Equal(EmployeeGenerator.Default.CompanyName, employee.CompanyName); Assert.Equal(EmployeeGenerator.Default.CompanyId, employee.CompanyId); }
public async Task GetByAgeAsync() { var employee19 = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 19)); var employee20 = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 20)); await _client.RefreshAsync(); var results = await _employeeRepository.GetAllByAgeAsync(employee19.Age); Assert.Equal(1, results.Total); Assert.Equal(employee19, results.Documents.First()); results = await _employeeRepository.GetAllByAgeAsync(employee20.Age); Assert.Equal(1, results.Total); Assert.Equal(employee20, results.Documents.First()); }