public async Task <ValidationModel <TypeBurial> > UpdateValidationAsync(TypeBurial newEntity, CancellationToken cancellationToken = default)
{
if (newEntity is not null)
{
if (!await dataTypeBurial.ExistByIdAsync(newEntity.Id, cancellationToken))
{
validation.Errors.Add(nameof(TypeBurial),
string.Format(BaseValidation.ObjectNotExistById, nameof(TypeBurial), newEntity.Id));
}
else if (await dataTypeBurial.ExistAsync(newEntity, cancellationToken))
{
validation.Errors.Add(nameof(TypeBurial),
string.Format(BaseValidation.ObjectExistWithThisData, nameof(TypeBurial)));
}
if (newEntity.Name is null)
{
validation.Errors.Add(nameof(TypeBurial.Name),
string.Format(BaseValidation.FieldNotCanBeNull, nameof(TypeBurial.Name)));
}
else if (newEntity.Name.Length < 3 || newEntity.Name.Length > 128)
{
validation.Errors.Add(nameof(TypeBurial.Name),
string.Format(BaseValidation.FieldInvalidLength, nameof(TypeBurial.Name), 3, 128));
}
}
else
{
validation.Errors.Add(nameof(TypeBurial),
string.Format(BaseValidation.ObjectNotCanBeNull, nameof(TypeBurial)));
}
return(validation);
}
public async Task UpdateValidationAsync_Null_UnSucces()
{
// Arrange
MockData(
isExistTypeBurial: true,
isExistTypeBurialById: true
);
TypeBurial entity = null;
var listError = new Dictionary <string, string>()
{
{ nameof(TypeBurial), string.Format(BaseValidation.ObjectNotCanBeNull, nameof(TypeBurial)) }
};
// Act
var result = await _validation.UpdateValidationAsync(entity);
// Assert
Assert.Multiple(() =>
{
Assert.NotNull(result.Errors);
Assert.IsNotEmpty(result.Errors);
Assert.IsFalse(result.IsValid);
foreach (var error in result.Errors)
{
Assert.IsTrue(listError.ContainsKey(error.Key));
Assert.AreEqual(listError[error.Key], error.Value);
}
});
}
public async Task TestUpdateAsync()
{
// Arrange
var random = new Random(0);
var number = random.Next(5);
var entity = GetList()[number];
await _service.InsertAsync(entity);
_dbContext.Entry(entity).State = EntityState.Detached;
entity = new TypeBurial()
{
Id = entity.Id,
Name = "Тип № Тест",
CreatedAt = DateTime.Now.AddMinutes(60),
UpdatedAt = DateTime.Now.AddMinutes(60)
};
await _service.UpdateAsync(entity);
_dbContext.Entry(entity).State = EntityState.Detached;
// Act
var result = await _service.GetAsync(entity.Id);
_dbContext.Entry(result).State = EntityState.Detached;
// Assert
Assert.IsTrue(entity.Name == result.Name);
Assert.IsTrue(entity.CreatedAt == result.CreatedAt);
Assert.IsTrue(entity.UpdatedAt == result.UpdatedAt);
}
public async Task <TypeBurial> UpdateAsync(TypeBurial entity, CancellationToken cancellationToken)
{
db.TypeBurials.Update(entity);
await db.SaveChangesAsync(cancellationToken);
return(entity);
}
public async Task <TypeBurial> InsertAsync(TypeBurial entity, CancellationToken cancellationToken)
{
await db.TypeBurials.AddAsync(entity, cancellationToken);
await db.SaveChangesAsync(cancellationToken);
return(entity);
}
public async Task <ValidationModel <TypeBurial> > InsertAsync(TypeBurial newEntity, CancellationToken cancellationToken = default)
{
var validation = await typeBurialValidation.InsertValidationAsync(newEntity, cancellationToken);
if (!validation.IsValid)
{
return(validation);
}
newEntity.CreatedAt = DateTime.Now;
newEntity.UpdatedAt = DateTime.Now;
validation.Result = await dataTypeBurial.InsertAsync(newEntity, cancellationToken);
return(validation);
}
private void MockData(
TypeBurial typeBurial = default,
IEnumerable <TypeBurial> typeBurialList = default,
ValidationModel <TypeBurial> validationTypeBurial = default
)
{
_dataTypeBurial.Setup(x => x.GetAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(typeBurial);
_dataTypeBurial.Setup(x => x.GetAllAsync(It.IsAny <CancellationToken>())).ReturnsAsync(typeBurialList);
_dataTypeBurial.Setup(x => x.InsertAsync(It.IsAny <TypeBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(typeBurial);
_dataTypeBurial.Setup(x => x.UpdateAsync(It.IsAny <TypeBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(typeBurial);
_dataTypeBurial.Setup(x => x.DeleteAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>()));
_typeBurialValidation.Setup(x => x.GetValidationAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationTypeBurial);
_typeBurialValidation.Setup(x => x.InsertValidationAsync(It.IsAny <TypeBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationTypeBurial);
_typeBurialValidation.Setup(x => x.UpdateValidationAsync(It.IsAny <TypeBurial>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationTypeBurial);
_typeBurialValidation.Setup(x => x.DeleteValidationAsync(It.IsAny <Guid>(), It.IsAny <CancellationToken>())).ReturnsAsync(validationTypeBurial);
_service = new TypeBurialService(_dataTypeBurial.Object, _typeBurialValidation.Object);
}
public async Task <bool> ExistAsync(TypeBurial entity, CancellationToken cancellationToken)
{
return(await db.TypeBurials.AnyAsync(db =>
db.Name == entity.Name,
cancellationToken));
}
