private static async Task PlayWithDb()
{
var companyRepo = new CompanyRepository(ConnectionString);
foreach (var e in await companyRepo.GetAllAsync())
{
WriteLine(e);
}
WriteLine("---");
var employeeRepo = new EmployeeRepository(ConnectionString);
foreach (var e in await employeeRepo.GetAllAsync())
{
WriteLine(e);
}
var employee1 = new Employee
{
Name1 = "Вадим",
Name2 = "Ярень",
EmploymentDate = DateTime.Now
};
await employeeRepo.AddAsync(employee1);
var employee2 = new Employee
{
Name1 = "Рей",
Name2 = "Ером",
EmploymentDate = DateTime.Now
};
await employeeRepo.AddAsync(employee2);
foreach (var e in await employeeRepo.GetAllAsync())
{
WriteLine(e);
}
WriteLine();
employee2.Name1 = "Джим";
await employeeRepo.UpdateAsync(employee2);
foreach (var e in await employeeRepo.GetAllAsync())
{
WriteLine(e);
}
WriteLine();
await employeeRepo.DeleteAsync(2);
foreach (var e in await employeeRepo.GetAllAsync())
{
WriteLine(e);
}
}
public async Task CanCreateMonthlyAliases(DateTime utcNow) {
SystemClock.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.GetAliasesAsync(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 Employee_Repository_Should_Add_Employee()
{
// Arrange
var context = TestSetUpHelper.CreateDbContext();
var repository = new EmployeeRepository(context);
var expectedEntity = new Employee()
{
Post = new Post()
{
Name = "Big Boss", Id = 5
},
FirstName = "test",
LastName = "Maksymiv",
ShortName = "lv420",
BoardNumber = 228,
Id = 20
};
// Act
await repository.AddAsync(expectedEntity);
await context.SaveChangesAsync();
var actualEntity = await repository.GetByIdAsync(expectedEntity.Id);
// Assert
Assert.Equal(expectedEntity, actualEntity);
}
public async Task Employee_Repository_Should_Get_All()
{
// Arrange
var context = TestSetUpHelper.CreateDbContext();
var repository = new EmployeeRepository(context);
var expectedEntity = new Employee()
{
Post = new Post()
{
Name = "Big Boss", Id = 5
},
FirstName = "test",
LastName = "Maksymiv",
ShortName = "lv420",
BoardNumber = 228,
Id = 20
};
// Act
await repository.AddAsync(expectedEntity);
await context.SaveChangesAsync();
var entities = await repository.GetAllAsync();
// Assert
Assert.Single(entities.ToList());
}
private static async Task AddEmployeeWithCompaniesAndPosts()
{
var company1 = new Company {
Id = 1
};
var company2 = new Company {
Id = 2
};
var post1 = new Post {
Id = 1
};
var post2 = new Post {
Id = 2
};
var employee = new Employee
{
Name1 = "Name111",
Name2 = "Name222",
Name3 = "Name333",
EmploymentDate = DateTime.Now,
Companies = new[] { company1, company2 },
Posts = new[] { post1, post2 }
};
var repo = new EmployeeRepository(ConnectionString);
await repo.AddAsync(employee);
}
public void async_crud_process_succeeds()
{
var employee = new Employee
{
Id = 77777
, FirstName = "Unit"
, MiddleName = "T."
, LastName = "Test"
, JobId = 11
, EmployeeCode = "POK93028M"
, JobLevel = 85
, PublisherId = 1
, HireDate = TestRunDate
};
var savedEmployee = _repository.AddAsync(employee).Result;
var updatedEmployee = _repository.GetByIdAsync(savedEmployee.Id).Result;
using (new AssertionScope())
{
savedEmployee.Should().NotBeNull();
savedEmployee.Id.Should().Be(77777);
savedEmployee.FirstName.Should().Be("Unit");
updatedEmployee.Id.Should().Be(savedEmployee.Id);
updatedEmployee.FirstName = "UnitUnit";
_ = _repository.UpdateAsync(updatedEmployee);
updatedEmployee = _repository.GetByIdAsync(savedEmployee.Id).Result;
updatedEmployee.FirstName.Should().Be("UnitUnit");
_ = _repository.DeleteAsync(updatedEmployee);
_repository.GetByIdAsync(savedEmployee.Id).Result.Should().BeNull();
}
}
public override void Handle(BrokeredMessage message)
{
var employeeRepository = new EmployeeRepository(new MyCompanyContext());
var dto = message.GetBody <EmployeeDTO>();
var employee = Mapper.Map <Employee>(dto);
employeeRepository.AddAsync(employee).Wait();
}
public async Task <Employee> AddEmployee([FromBody] Employee item)
{
var ret = await _employeeService.AddAsync(item);
ret.DDump("http://localhost:5000/api/employees - [Employees - POST] Item: ");
ret.CDump("http://localhost:5000/api/employees - [Employees - POST] Item: ");
return(ret);
}
public async Task AddAsync_StateUnderTest_ExpectedBehavior()
{
// Arrange
// Act
var emp = await employeeRepository.AddAsync(employee, token);
// Assert
Assert.IsNotNull(emp);
}
public override void Handle(BrokeredMessage message)
{
var employeeRepository = new EmployeeRepository(new MyCompanyContext());
var dto = message.GetBody <EmployeeDTO>();
var employee = Mapper.Map <Employee>(dto);
var current = employeeRepository.GetAsync(employee.EmployeeId).Result;
if (current == null)
{
employeeRepository.AddAsync(employee).Wait();
}
}
public async Task EmployeeRepository_AddEmployee_Added_NotFail_Test()
{
var context = new MyCompanyContext();
int expected = context.Employees.Count() + 1;
var target = new EmployeeRepository(context);
var employeeId = context.Employees.Select(e => e.EmployeeId).Max() + 1;
var employee = new Employee()
{
EmployeeId = employeeId,
FirstName = "Andrew",
LastName = "Davis",
Email = "*****@*****.**",
};
await target.AddAsync(employee);
int actual = context.Employees.Count();
Assert.AreEqual(expected, actual);
}
public async Task CanReindexVersionedIndexWithDataInBothIndexes() {
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 version1Repository = new EmployeeRepository(version1Index.Employee);
var employee = await version1Repository.AddAsync(EmployeeGenerator.Default);
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) {
await version2Index.ConfigureAsync();
Assert.True(_client.IndexExists(version2Index.VersionedName).Exists);
// swap the alias so we write to v1 and v2 and try to reindex.
await _client.AliasAsync(x => x
.Remove(a => a.Alias(version1Index.Name).Index(version1Index.VersionedName))
.Add(a => a.Alias(version2Index.Name).Index(version2Index.VersionedName)));
var version2Repository = new EmployeeRepository(version2Index.Employee);
await version2Repository.AddAsync(EmployeeGenerator.Generate());
await _client.RefreshAsync();
var countResponse = await _client.CountAsync(d => d.Index(version1Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(1, countResponse.Count);
countResponse = await _client.CountAsync(d => d.Index(version2Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(1, countResponse.Count);
// swap back the alias
await _client.AliasAsync(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.GetAliasAsync(descriptor => descriptor.Alias(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.GetAliasAsync(descriptor => descriptor.Alias(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(d => d.Index(version2Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(2, countResponse.Count);
Assert.False(_client.IndexExists(d => d.Index(version1Index.VersionedName)).Exists);
}
}
}
public async Task DailyAliasMaxAge(DateTime utcNow) {
SystemClock.SetFixedTime(utcNow);
var index = new DailyEmployeeIndex(_configuration, 1);
index.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));
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
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.GetAliasesAsync(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)));
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.True(existsResponse.Exists);
aliasesResponse = await _client.GetAliasesAsync(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)));
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.True(existsResponse.Exists);
aliasesResponse = await _client.GetAliasesAsync(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 <Employee> Post([FromBody] Employee item)
{
return(await _employeeService.AddAsync(item));
}
public async Task MaintainDailyIndexes() {
var index = new DailyEmployeeIndex(_configuration, 1);
await index.DeleteAsync();
using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) {
await index.ConfigureAsync();
var repository = new EmployeeRepository(index.Employee);
SystemClock.AdjustTime(TimeSpan.FromDays(15));
var employee = await repository.AddAsync(EmployeeGenerator.Generate(createdUtc: SystemClock.UtcNow));
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
await index.MaintainAsync();
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.GetAliasesAsync(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, SystemClock.UtcNow, employee.CreatedUtc), String.Join(", ", aliases));
SystemClock.AdjustTime(TimeSpan.FromDays(9));
index.MaxIndexAge = TimeSpan.FromDays(10);
await index.MaintainAsync();
existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.True(existsResponse.Exists);
aliasesResponse = await _client.GetAliasesAsync(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, SystemClock.UtcNow, employee.CreatedUtc), String.Join(", ", aliases));
SystemClock.Reset();
await index.MaintainAsync();
existsResponse = await _client.IndexExistsAsync(index.GetIndex(employee.CreatedUtc));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.False(existsResponse.Exists);
aliasesResponse = await _client.GetAliasesAsync(a => a.Index(index.GetIndex(employee.CreatedUtc)));
_logger.Trace(() => aliasesResponse.GetRequest());
Assert.True(aliasesResponse.IsValid);
Assert.Equal(0, aliasesResponse.Indices.Count);
}
}
public async Task CanReindexSameIndex() {
var index = new EmployeeIndex(_configuration);
await index.DeleteAsync();
using (new DisposableAction(() => index.DeleteAsync().GetAwaiter().GetResult())) {
await index.ConfigureAsync();
Assert.True(_client.IndexExists(index.Name).Exists);
var repository = new EmployeeRepository(index.Employee);
var employee = await repository.AddAsync(EmployeeGenerator.Default);
await _client.RefreshAsync();
Assert.NotNull(employee?.Id);
var countResponse = await _client.CountAsync(d => d.Index(index.Name));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(1, countResponse.Count);
var mappingResponse = await _client.GetMappingAsync<Employee>(m => m.Index(index.Name));
_logger.Trace(() => mappingResponse.GetRequest());
Assert.True(mappingResponse.IsValid);
Assert.NotNull(mappingResponse.Mappings);
var newIndex = new EmployeeIndexWithYearsEmployed(_configuration);
await newIndex.ReindexAsync();
countResponse = await _client.CountAsync(d => d.Index(index.Name));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(1, countResponse.Count);
string version1Mappings = ToJson(mappingResponse.Mappings);
mappingResponse = await _client.GetMappingAsync<Employee>(m => m.Index(index.Name));
_logger.Trace(() => mappingResponse.GetRequest());
Assert.True(mappingResponse.IsValid);
Assert.NotNull(mappingResponse.Mappings);
Assert.NotEqual(version1Mappings, ToJson(mappingResponse.Mappings));
}
}
public async Task CanResumeReindex() {
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(_client.IndexExists(version1Index.VersionedName).Exists);
var version1Repository = new EmployeeRepository(version1Index.Employee);
await version1Repository.AddAsync(EmployeeGenerator.GenerateEmployees(numberOfEmployeesToCreate));
await _client.RefreshAsync();
var countResponse = await _client.CountAsync(d => d.Index(version1Index.Name));
_logger.Trace(() => countResponse.GetRequest());
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(_client.IndexExists(version2Index.VersionedName).Exists);
await Assert.ThrowsAsync<ApplicationException>(async () => await version2Index.ReindexAsync((progress, message) => {
_logger.Info("Reindex Progress {0}%: {1}", progress, message);
// TODO: Need to make this so it happens randomly in the middle of a batch
if (progress >= 45)
throw new ApplicationException("Random Error");
return Task.CompletedTask;
}));
Assert.Equal(1, await version1Index.GetCurrentVersionAsync());
await version2Index.ReindexAsync();
var aliasResponse = await _client.GetAliasAsync(descriptor => descriptor.Alias(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(d => d.Index(version2Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(numberOfEmployeesToCreate, countResponse.Count);
Assert.False(_client.IndexExists(d => d.Index(version1Index.VersionedName)).Exists);
}
}
}
public async Task CanReindexTimeSeriesIndexWithCorrectMappings() {
var version1Index = new DailyEmployeeIndex(_configuration, 1);
await version1Index.DeleteAsync();
var version2Index = new DailyEmployeeIndex(_configuration, 2);
version2Index.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));
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
using (new DisposableAction(() => version2Index.DeleteAsync().GetAwaiter().GetResult())) {
await version2Index.ConfigureAsync();
await version2Index.ReindexAsync();
var existsResponse = await _client.IndexExistsAsync(d => d.Index(version1Index.GetVersionedIndex(utcNow, 1)));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.True(existsResponse.Exists);
var mappingResponse = await _client.GetMappingAsync<Employee>(m => m.Index(version1Index.GetVersionedIndex(utcNow, 1)));
_logger.Trace(() => mappingResponse.GetRequest());
Assert.True(mappingResponse.IsValid);
Assert.NotNull(mappingResponse.Mappings);
existsResponse = await _client.IndexExistsAsync(d => d.Index(version2Index.GetVersionedIndex(utcNow, 2)));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.True(existsResponse.Exists);
string version1Mappings = ToJson(mappingResponse.Mappings);
mappingResponse = await _client.GetMappingAsync<Employee>(m => m.Index(version1Index.GetVersionedIndex(utcNow, 2)));
_logger.Trace(() => mappingResponse.GetRequest());
Assert.True(mappingResponse.IsValid);
Assert.NotNull(mappingResponse.Mappings);
Assert.Equal(version1Mappings, ToJson(mappingResponse.Mappings).Replace("-v2", "-v1"));
}
}
}
public async Task CanReindexTimeSeriesIndex() {
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();
var version1Repository = new EmployeeRepository(version1Index.Employee);
var utcNow = SystemClock.UtcNow;
var employee = await version1Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow));
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
Assert.Equal(1, await version1Index.GetCurrentVersionAsync());
var aliasCountResponse = await _client.CountAsync(d => d.Index(version1Index.Name));
_logger.Trace(() => aliasCountResponse.GetRequest());
Assert.True(aliasCountResponse.IsValid);
Assert.Equal(1, aliasCountResponse.Count);
var indexCountResponse = await _client.CountAsync(d => d.Index(version1Index.GetIndex(utcNow)));
_logger.Trace(() => indexCountResponse.GetRequest());
Assert.True(indexCountResponse.IsValid);
Assert.Equal(1, indexCountResponse.Count);
indexCountResponse = await _client.CountAsync(d => d.Index(version1Index.GetVersionedIndex(utcNow, 1)));
_logger.Trace(() => indexCountResponse.GetRequest());
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());
var version2Repository = new EmployeeRepository(version2Index.Employee);
// Make sure we write to the old index.
await version2Repository.AddAsync(EmployeeGenerator.Generate(createdUtc: utcNow));
await _client.RefreshAsync();
aliasCountResponse = await _client.CountAsync(d => d.Index(version1Index.Name));
_logger.Trace(() => aliasCountResponse.GetRequest());
Assert.True(aliasCountResponse.IsValid);
Assert.Equal(2, aliasCountResponse.Count);
indexCountResponse = await _client.CountAsync(d => d.Index(version1Index.GetVersionedIndex(utcNow, 1)));
_logger.Trace(() => indexCountResponse.GetRequest());
Assert.True(indexCountResponse.IsValid);
Assert.Equal(2, indexCountResponse.Count);
var existsResponse = await _client.IndexExistsAsync(d => d.Index(version2Index.GetVersionedIndex(utcNow, 2)));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.False(existsResponse.Exists);
// alias should still point to the old version until reindex
var aliasesResponse = await _client.GetAliasesAsync(a => a.Index(version1Index.GetIndex(employee.CreatedUtc)));
_logger.Trace(() => aliasesResponse.GetRequest());
Assert.True(aliasesResponse.IsValid);
Assert.Equal(version1Index.GetVersionedIndex(employee.CreatedUtc, 1), aliasesResponse.Indices.Single().Key);
var aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).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.GetAliasesAsync(a => a.Index(version1Index.GetIndex(employee.CreatedUtc)));
_logger.Trace(() => aliasesResponse.GetRequest());
Assert.True(aliasesResponse.IsValid);
Assert.Equal(version1Index.GetVersionedIndex(employee.CreatedUtc, 2), aliasesResponse.Indices.Single().Key);
aliases = aliasesResponse.Indices.Values.Single().Select(s => s.Name).ToList();
aliases.Sort();
Assert.Equal(GetExpectedEmployeeDailyAliases(version1Index, utcNow, employee.CreatedUtc), String.Join(", ", aliases));
existsResponse = await _client.IndexExistsAsync(d => d.Index(version1Index.GetVersionedIndex(utcNow, 1)));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.False(existsResponse.Exists);
existsResponse = await _client.IndexExistsAsync(d => d.Index(version2Index.GetVersionedIndex(utcNow, 2)));
_logger.Trace(() => existsResponse.GetRequest());
Assert.True(existsResponse.IsValid);
Assert.True(existsResponse.Exists);
}
}
}
public async Task CanReindexVersionedIndexWithDeletedDocs() {
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);
Assert.NotNull(employee?.Id);
await _client.RefreshAsync();
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.Alias(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.Info($"Reindex Progress {progress}%: {message}");
if (progress == 95) {
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.RemoveAllAsync();
await _client.RefreshAsync();
// Resume after everythings been indexed.
await reindexTask;
aliasResponse = await _client.GetAliasAsync(descriptor => descriptor.Alias(version2Index.Name));
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(d => d.Index(version1Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.ConnectionStatus.HttpStatusCode == 404, countResponse.GetErrorMessage());
Assert.Equal(0, countResponse.Count);
countResponse = await _client.CountAsync(d => d.Index(version2Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid, countResponse.GetErrorMessage());
Assert.Equal(1, countResponse.Count);
Assert.Equal(employee, await repository.GetByIdAsync(employee.Id));
Assert.False(_client.IndexExists(d => d.Index(version1Index.VersionedName)).Exists);
}
}
}
public async Task CanReindexVersionedIndex() {
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 indexes = _client.GetIndicesPointingToAlias(version1Index.Name);
Assert.Equal(1, indexes.Count);
var aliasResponse = await _client.GetAliasAsync(descriptor => descriptor.Alias(version1Index.Name));
_logger.Trace(() => aliasResponse.GetRequest());
Assert.True(aliasResponse.IsValid);
Assert.Equal(1, aliasResponse.Indices.Count);
Assert.Equal(version1Index.VersionedName, aliasResponse.Indices.First().Key);
var version1Repository = new EmployeeRepository(version1Index.Employee);
var employee = await version1Repository.AddAsync(EmployeeGenerator.Default);
await _client.RefreshAsync();
Assert.NotNull(employee?.Id);
var countResponse = await _client.CountAsync(d => d.Index(version1Index.Name));
_logger.Trace(() => countResponse.GetRequest());
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(_client.IndexExists(version2Index.VersionedName).Exists);
// Make sure we can write to the index still. Should go to the old index until after the reindex is complete.
var version2Repository = new EmployeeRepository(version2Index.Employee);
await version2Repository.AddAsync(EmployeeGenerator.Generate());
await _client.RefreshAsync();
countResponse = await _client.CountAsync(d => d.Index(version1Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(2, countResponse.Count);
countResponse = await _client.CountAsync(d => d.Index(version2Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
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.GetAliasAsync(descriptor => descriptor.Alias(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.GetAliasAsync(descriptor => descriptor.Alias(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(d => d.Index(version2Index.VersionedName));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(2, countResponse.Count);
Assert.False(_client.IndexExists(d => d.Index(version1Index.VersionedName)).Exists);
employee = await version2Repository.AddAsync(EmployeeGenerator.Default);
await _client.RefreshAsync();
Assert.NotNull(employee?.Id);
countResponse = await _client.CountAsync(d => d.Index(version2Index.Name));
_logger.Trace(() => countResponse.GetRequest());
Assert.True(countResponse.IsValid);
Assert.Equal(3, countResponse.Count);
}
}
}