public async Task HandleAsync_Should_Delete_CityDistrict()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
var getCityDistrictResult = GetResult <CityDistrict> .Ok(cityDistrict);
var command = new DeleteCityDistrictCommand(cityDistrict.Id, cityDistrict.RowVersion);
_cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getCityDistrictResult);
_cityDistrictRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <CityDistrict>())).Returns(Task.CompletedTask);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
await result.Should().NotThrowAsync <Exception>();
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_CityDistrictOutputQuery_When_Input_Is_Not_Null()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetParentId(Guid.NewGuid())
.Build();
var cityDistrictsInputQuery = new GetCityDistrictsInputQuery(1, 100, "name:asc", cityDistrict.Name,
cityDistrict.PolishName, cityDistrict.CityId, cityDistrict.ParentId, new List <Guid>());
var cityDistricts = new List <CityDistrict> {
cityDistrict
};
var cityDistrictOutputQueries = cityDistricts.Select(x =>
new CityDistrictOutputQuery(x.Id, x.RowVersion, x.Name, x.PolishName, x.CityId, x.ParentId, x.NameVariants)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <CityDistrictOutputQuery>(cityDistricts.Count, cityDistrictOutputQueries);
_cityDistrictRepositoryMock
.Setup(x => x.FindAsync(It.IsAny <int?>(), It.IsAny <int?>(), It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid?>(), It.IsAny <Guid?>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityDistricts);
_cityDistrictRepositoryMock
.Setup(x => x.CountAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid?>(), It.IsAny <Guid?>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityDistricts.Count);
_mapperMock.Setup(x =>
x.Map <List <CityDistrict>, IEnumerable <CityDistrictOutputQuery> >(It.IsAny <List <CityDistrict> >()))
.Returns(cityDistrictOutputQueries);
var result = await _queryHandler.HandleAsync(cityDistrictsInputQuery);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task GetAllAsync_Should_Return_CityDistricts_Collection()
{
var cityDistrictEntities = await _dbContext.CityDistricts
.Include(x => x.NameVariants)
.ToListAsync();
var cityDistricts = cityDistrictEntities.Select(x =>
CityDistrict.Builder()
.SetId(x.Id)
.SetRowVersion(x.RowVersion)
.SetName(x.Name)
.SetPolishName(x.PolishName)
.SetCityId(x.CityId)
.SetParentId(x.ParentId)
.SetNameVariants(x.NameVariants.Select(nv => nv.Value).ToArray())
.Build()
).ToList();
object cachedCityDistricts = null;
var cacheEntryMock = new Mock <ICacheEntry>();
_memoryCacheMock.Setup(x => x.TryGetValue(It.IsAny <object>(), out cachedCityDistricts)).Returns(false);
_memoryCacheMock.Setup(x => x.CreateEntry(It.IsAny <object>())).Returns(cacheEntryMock.Object);
_mapperMock.Setup(x => x.Map <List <CityDistrictEntity>, List <CityDistrict> >(It.IsAny <List <CityDistrictEntity> >()))
.Returns(cityDistricts);
var result = await _repository.GetAllAsync();
result.Should().BeEquivalentTo(cityDistricts);
}
public async Task HandleAsync_Should_Throw_PreconditionFailedException_When_RowVersion_Does_Not_Match()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(new byte[] { 1, 2, 4, 8, 16, 32, 64 })
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
var getCityDistrictResult = GetResult <CityDistrict> .Ok(cityDistrict);
var command = new DeleteCityDistrictCommand(cityDistrict.Id, new byte[] { 1, 2, 4, 8, 16, 32, 128 });
_cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getCityDistrictResult);
_cityDistrictRepositoryMock.Setup(x => x.DeleteAsync(It.IsAny <CityDistrict>())).Returns(Task.CompletedTask);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
await result.Should().ThrowExactlyAsync <PreconditionFailedException>();
}
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetParentId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.Build();
var getCityDistrict = GetResult <CityDistrict> .Ok(cityDistrict);
var city = City.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var parentExistsVerificationResult = VerificationResult.Ok();
var nameIsNotTakenError = new Error(CityDistrictErrorCodeEnumeration.NameAlreadyInUse, CityDistrictErrorMessage.NameAlreadyInUse);
var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
nameIsNotTakenError
});
var polishNameIsNotTakenError = new Error(CityDistrictErrorCodeEnumeration.PolishNameAlreadyInUse, CityDistrictErrorMessage.PolishNameAlreadyInUse);
var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
polishNameIsNotTakenError
});
var command = new UpdateCityDistrictCommand(cityDistrict.Id, cityDistrict.RowVersion, "NewName",
"NewPolishName", city.Id, Guid.NewGuid(), new Collection <string> {
"NewNameVariant"
});
var errors = new Collection <IError> {
nameIsNotTakenError, polishNameIsNotTakenError
};
_cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getCityDistrict);
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_cityDistrictVerificationServiceMock.Setup(x => x.VerifyParentExistsAsync(It.IsAny <Guid>()))
.ReturnsAsync(parentExistsVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public CityDistrictRepositoryTestFixture(DatabaseFixture fixture)
{
DbContext = fixture.DbContext;
MapperMock = new Mock <IMapper>();
OrderByExpressionCreatorMock = new Mock <IOrderByExpressionCreator <CityDistrict> >();
MemoryCacheMock = new Mock <IMemoryCache>();
Repository = new CityDistrictRepository(DbContext, MapperMock.Object, OrderByExpressionCreatorMock.Object, MemoryCacheMock.Object);
CityEntity = InsertCityEntity();
CityDistrict = InsertCityDistrict("CityDistrictRepositoryTest");
}
public async Task AddAsync(CityDistrict cityDistrict)
{
var cityDistrictEntity = _mapper.Map <CityDistrict, CityDistrictEntity>(cityDistrict);
_cityDistrictEntityDbSet.Add(cityDistrictEntity);
await _dbContext.SaveChangesAsync();
cityDistrict.SetRowVersion(cityDistrictEntity.RowVersion);
_cache.Remove(CacheKeys.CityDistrictsKey);
}
public CityDistrictRepositoryTest(CityDistrictRepositoryTestFixture fixture)
{
_dbContext = fixture.DbContext;
_mapperMock = fixture.MapperMock;
_orderByExpressionCreatorMock = fixture.OrderByExpressionCreatorMock;
_memoryCacheMock = fixture.MemoryCacheMock;
_repository = fixture.Repository;
_cityDistrict = fixture.CityDistrict;
_cityEntity = fixture.CityEntity;
_fixture = fixture;
}
public async Task UpdateAsync(CityDistrict cityDistrict)
{
var cityDistrictEntity = await GetCityDistrictEntityByIdWithNameVariantEntitiesAsync(cityDistrict.Id);
UpdateCityDistrictEntityAttributes(cityDistrictEntity, cityDistrict);
UpdateCityDistrictNameVariantEntities(cityDistrictEntity, cityDistrict);
_dbContext.Entry(cityDistrictEntity).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
cityDistrict.SetRowVersion(cityDistrictEntity.RowVersion);
_cache.Remove(CacheKeys.CityDistrictsKey);
}
public async Task DeleteAsync(CityDistrict cityDistrict)
{
var cityDistrictEntity = new CityDistrictEntity
{
Id = cityDistrict.Id,
RowVersion = cityDistrict.RowVersion.ToArray()
};
_dbContext.AttachEntity(cityDistrictEntity);
_dbContext.Entry(cityDistrictEntity).State = EntityState.Deleted;
await _dbContext.SaveChangesAsync();
_cache.Remove(CacheKeys.CityDistrictsKey);
}
private async Task UpdateCityIdAsync(CityDistrict cityDistrict, Guid cityId)
{
if (cityDistrict.CityId != cityId)
{
var getCityResult = await _cityGetterService.GetByIdAsync(cityId);
if (!getCityResult.Success)
{
throw new ValidationException(getCityResult.Errors);
}
cityDistrict.ChangeCityId(cityId);
}
}
public async Task HandleAsync_Should_Update_CityDistrict()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetParentId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.Build();
var getCityDistrict = GetResult <CityDistrict> .Ok(cityDistrict);
var city = City.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var parentExistsVerificationResult = VerificationResult.Ok();
var nameIsNotTakenVerificationResult = VerificationResult.Ok();
var polishNameIsNotTakenVerificationResult = VerificationResult.Ok();
var command = new UpdateCityDistrictCommand(cityDistrict.Id, cityDistrict.RowVersion, "NewName",
"NewPolishName", city.Id, Guid.NewGuid(), new Collection <string> {
"NewNameVariant"
});
_cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getCityDistrict);
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_cityDistrictVerificationServiceMock.Setup(x => x.VerifyParentExistsAsync(It.IsAny <Guid>()))
.ReturnsAsync(parentExistsVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
_cityDistrictRepositoryMock.Setup(x => x.UpdateAsync(It.IsAny <CityDistrict>())).Returns(Task.CompletedTask);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
await result.Should().NotThrowAsync <Exception>();
}
private static void UpdateNameVariants(CityDistrict cityDistrict, ICollection <string> nameVariants)
{
var nameVariantsToRemove = cityDistrict.NameVariants.Except(nameVariants).ToList();
var nameVariantsToAdd = nameVariants.Except(cityDistrict.NameVariants).ToList();
foreach (var nameVariant in nameVariantsToRemove)
{
cityDistrict.RemoveNameVariant(nameVariant);
}
foreach (var nameVariant in nameVariantsToAdd)
{
cityDistrict.AddNameVariant(nameVariant);
}
}
public void Should_Create_CityDistrict()
{
var result = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(null)
.Build();
result.Should().NotBeNull();
}
public CityDistrictProfile()
{
CreateMap <CityDistrictEntity, CityDistrict>()
.ForMember(x => x.RowVersion, opt => opt.Ignore())
.ForMember(x => x.NameVariants, opt => opt.Ignore())
.ConvertUsing(x => CityDistrict.Builder()
.SetId(x.Id)
.SetRowVersion(x.RowVersion)
.SetName(x.Name)
.SetPolishName(x.PolishName)
.SetCityId(x.CityId)
.SetParentId(x.ParentId)
.SetNameVariants(x.NameVariants.Select(nv => nv.Value).ToArray())
.Build());
CreateMap <CityDistrict, CityDistrictEntity>().ConvertUsing <CityDistrictEntityTypeConverter>();
}
private async Task UpdateParentIdAsync(CityDistrict cityDistrict, Guid?parentId)
{
if (cityDistrict.ParentId != parentId)
{
if (parentId.HasValue)
{
var verificationResult = await _cityDistrictVerificationService.VerifyParentExistsAsync(parentId.Value);
if (!verificationResult.Success)
{
throw new ValidationException(verificationResult.Errors);
}
}
cityDistrict.ChangeParentId(parentId);
}
}
public CityDistrictProfile()
{
CreateMap <CityDistrict, CityDistrictOutputQuery>();
CreateMap <CreateCityDistrictCommand, CityDistrict>()
.ForMember(x => x.NameVariants, opt => opt.Ignore())
.ConstructUsing(x =>
CityDistrict
.Builder()
.SetId(x.CityDistrictId)
.SetRowVersion(Array.Empty <byte>())
.SetName(x.Name)
.SetPolishName(x.PolishName)
.SetCityId(x.CityId)
.SetParentId(x.ParentId)
.SetNameVariants(x.NameVariants.ToArray())
.Build());
}
public void Should_Throw_CityDistrictNameVariantsNullException_When_NameVariants_Is_Null()
{
Action result = () =>
{
var unused = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(null)
.SetParentId(Guid.NewGuid())
.Build();
};
result.Should().ThrowExactly <CityDistrictNameVariantsNullException>()
.WithMessage("NameVariants argument is required.");
}
public void ChangeParentId_Should_Change_ParentId()
{
var parentId = Guid.NewGuid();
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
cityDistrict.ChangeParentId(parentId);
cityDistrict.ParentId.Should().Be(parentId);
}
public void ChangePolishName_Should_Change_PolishName()
{
const string polishName = "NewPolishName";
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
cityDistrict.ChangePolishName(polishName);
cityDistrict.PolishName.Should().BeEquivalentTo(polishName);
}
public void RemoveNameVariant_Should_Throw_CityDistrictNameVariantNullException_When_NameVariant_Is_Null_Or_Empty(string nameVariantToRemove)
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
Action result = () => cityDistrict.RemoveNameVariant(nameVariantToRemove);
result.Should().ThrowExactly <CityDistrictNameVariantNullException>()
.WithMessage("NameVariant argument is required.");
}
public void ChangeParentId_Should_Throw_CityDistrictCityIdNullException_When_ParentId_Is_Empty_Guid()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
Action result = () => cityDistrict.ChangeParentId(Guid.Empty);
result.Should().ThrowExactly <CityDistrictParentIdInvalidValueException>()
.WithMessage("ParentId argument is invalid.");
}
public void ChangePolishName_Should_Throw_CityDistrictPolishNameMaxLengthException_When_PolishName_Exceed_Allowed_Max_Length_Value()
{
var polishName = CreateString(257);
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
Action result = () => cityDistrict.ChangePolishName(polishName);
result.Should().ThrowExactly <CityDistrictPolishNameMaxLengthException>()
.WithMessage("PolishName argument max length is 256.");
}
public void Should_Throw_CityDistrictNameVariantsInvalidValueException_When_NameVariants_Contains_Null_Or_Empty_Value(string nameVariant)
{
Action result = () =>
{
var unused = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
nameVariant
})
.SetParentId(Guid.NewGuid())
.Build();
};
result.Should().ThrowExactly <CityDistrictNameVariantsInvalidValueException>()
.WithMessage("NameVariants argument is invalid.");
}
public async Task VerifyParentExistsAsync_Should_Return_Success_VerificationResult()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.Build();
var getCityDistrictResult = GetResult <CityDistrict> .Ok(cityDistrict);
var expectedResult = VerificationResult.Ok();
_cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getCityDistrictResult);
var result = await _service.VerifyParentExistsAsync(cityDistrict.Id);
result.Should().BeEquivalentTo(expectedResult);
}
public void Should_Throw_CityDistrictNameVariantsDuplicatedValuesException_When_NameVariants_Contains_Duplicated_Values()
{
Action result = () =>
{
var unused = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant", "NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
};
result.Should().ThrowExactly <CityDistrictNameVariantsDuplicatedValuesException>()
.WithMessage("NameVariants argument contains duplicate values.");
}
public void Should_Throw_CityDistrictPolishNameNullException_When_PolishName_Is_Null_Or_Empty(string polishName)
{
Action result = () =>
{
var unused = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName(polishName)
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.SetParentId(Guid.NewGuid())
.Build();
};
result.Should().ThrowExactly <CityDistrictPolishNameNullException>()
.WithMessage("PolishName argument is required.");
}
public async Task GetByIdAsync_Should_Return_GetResult_With_CityDistrict()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetParentId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.Build();
var expectedResult = GetResult <CityDistrict> .Ok(cityDistrict);
_cityDistrictRepositoryMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(cityDistrict);
var result = await _service.GetByIdAsync(cityDistrict.Id);
result.Should().BeEquivalentTo(expectedResult);
}
public void RemoveNameVariant_Should_Remove_NameVariant()
{
const string nameVariant = "NameVariant";
const string nameVariantToRemove = "NewNameVariantToRemove";
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetNameVariants(new List <string> {
nameVariant, nameVariantToRemove
})
.SetParentId(Guid.NewGuid())
.Build();
cityDistrict.RemoveNameVariant(nameVariantToRemove);
cityDistrict.NameVariants.Should().BeEquivalentTo(new Collection <string> {
nameVariant
});
}
public async Task VerifyNameIsNotTakenAsync_Should_Return_Fail_VerificationResult_When_CityDistrict_With_Given_Name_Already_Exist()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.Build();
var errors = new Collection <IError>
{
new Error(CityDistrictErrorCodeEnumeration.NameAlreadyInUse,
CityDistrictErrorMessage.NameAlreadyInUse)
};
var expectedResult = VerificationResult.Fail(errors);
_cityDistrictRepositoryMock.Setup(x => x.GetByNameAndCityIdAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(cityDistrict);
var result = await _service.VerifyNameIsNotTakenAsync("Name", Guid.NewGuid());
result.Should().BeEquivalentTo(expectedResult);
}
