public async Task Should_not_add_error_if_value_is_null()
{
var sut = new UniqueValidator(FoundDuplicates(DomainId.NewGuid()));
await sut.ValidateAsync(null, errors);
Assert.Empty(errors);
}
public async Task Should_not_add_error_if_string_value_not_found_but_in_optimized_mode()
{
var sut = new UniqueValidator(Check(DomainId.NewGuid()));
await sut.ValidateAsync(null, errors);
Assert.Empty(errors);
}
public async Task Should_not_add_error_if_string_value_found()
{
var sut = new UniqueValidator();
var filter = string.Empty;
await sut.ValidateAsync("hi", errors, Context(contentId, f => filter = f, ValidationMode.Default));
Assert.Empty(errors);
}
public async Task Should_not_add_error_if_string_value_not_found_but_in_optimized_mode()
{
var sut = new UniqueValidator();
var filter = string.Empty;
await sut.ValidateAsync("hi", errors, Context(Guid.NewGuid(), f => filter = f, ValidationMode.Optimized));
Assert.Empty(errors);
}
public async Task Should_not_add_error_if_same_content_with_double_value_found()
{
var ctx = ValidationTestExtensions.CreateContext().Nested("property").Nested("iv");
var sut = new UniqueValidator(FoundDuplicates(ctx.ContentId));
await sut.ValidateAsync(12.5, ctx, ValidationTestExtensions.CreateFormatter(errors));
Assert.Empty(errors);
}
public async Task Should_not_add_error_if_double_value_found_with_same_content_id()
{
var ctx = ValidationTestExtensions.CreateContext();
var sut = new UniqueValidator(Check(ctx.ContentId));
await sut.ValidateAsync(12.5, ctx, ValidationTestExtensions.CreateFormatter(errors));
Assert.Empty(errors);
}
public async Task Should_not_add_error_if_double_value_found()
{
var sut = new UniqueValidator();
var filter = string.Empty;
await sut.ValidateAsync(12.5, errors, Context(contentId, f => filter = f));
Assert.Empty(errors);
}
public void UniqueValidatorShouldReturnCorrectJSon()
{
//Arrange
var validator = new UniqueValidator();
//Act
var created = validator.CreateValidator();
var json = JsonConvert.SerializeObject(created);
//Assert
Assert.Equal(@"{""unique"":true}", json);
}
public async Task Should_not_check_uniqueness_if_localized_string()
{
var filter = string.Empty;
var sut = new UniqueValidator(FoundDuplicates(DomainId.NewGuid(), f => filter = f));
await sut.ValidateAsync(12.5, errors, updater : c => c.Nested("property").Nested("de"));
Assert.Empty(errors);
Assert.Empty(filter);
}
public async Task Should_add_error_if_other_content_with_string_value_found()
{
var filter = string.Empty;
var sut = new UniqueValidator(FoundDuplicates(DomainId.NewGuid(), f => filter = f));
await sut.ValidateAsync("hi", errors, updater : c => c.Nested("property").Nested("iv"));
errors.Should().BeEquivalentTo(
new[] { "property.iv: Another content with the same value exists." });
Assert.Equal("Data.property.iv == 'hi'", filter);
}
public async Task Should_add_error_if_string_value_not_found()
{
var sut = new UniqueValidator();
var filter = string.Empty;
await sut.ValidateAsync("hi", errors, Context(Guid.NewGuid(), f => filter = f));
errors.Should().BeEquivalentTo(
new[] { "property: Another content with the same value exists." });
Assert.Equal("Data.property.iv == 'hi'", filter);
}
public static IValidationResult Validate <T> (ValidationKind validationKind, T[] validationParameters, T checkedObject)
{
switch (validationKind)
{
case ValidationKind.Unique:
object[] validationParametersObjectArray = new object[validationParameters.Length];
validationParameters.CopyTo(validationParametersObjectArray, 0);
UniqueValidator <T> validator = new UniqueValidator <T>(validationParametersObjectArray, checkedObject);
return(validator.Validate( ));
default: throw new NotImplementedException("Not implemented switch in ValidatorProvider.Validate()");
}
}
public async Task Should_add_error_if_double_value_not_found()
{
var filter = string.Empty;
var sut = new UniqueValidator(Check(DomainId.NewGuid(), f => filter = f));
await sut.ValidateAsync(12.5, errors, updater : c => c.Nested("property").Nested("iv"));
errors.Should().BeEquivalentTo(
new[] { "property: Another content with the same value exists." });
Assert.Equal("Data.property.iv == 12.5", filter);
}
public void CanValidateUsingProperties()
{
var fullyValidData = TestingDataFactory.Unique.CreateUniqueData();
var duplicatedIdData = TestingDataFactory.Unique.CreateDuplicatedIdData();
var duplicatedLastNameData = TestingDataFactory.Unique.CreateDuplicatedLastNameData();
var duplicatedNamesData = TestingDataFactory.Unique.CreateDuplicatedNamesData();
var validatorById = new UniqueValidator <GenericParameter>(new Expression <Func <GenericParameter, object> >[]
{
x => x.ID
});
Assert.IsTrue(validatorById.Validate(fullyValidData.Collection).IsValid);
Assert.IsTrue(validatorById.Validate(duplicatedLastNameData.Collection).IsValid);
Assert.IsTrue(validatorById.Validate(duplicatedNamesData.Collection).IsValid);
var result = validatorById.Validate(duplicatedIdData.Collection);
Assert.IsFalse(result.IsValid);
var equals = duplicatedIdData.IsActualDuplicatesCorrect(((UniqueValidationResult)result.First()).DuplicatedItems);
Assert.IsTrue(equals);
var expectedErrorMessage = "Duplicated items were found in collection";
var actualErrorMessage = result.First().ErrorMessage;
Assert.AreEqual(expectedErrorMessage, actualErrorMessage);
var validatorByNames =
new UniqueValidator <GenericParameter>(
new Expression <Func <GenericParameter, object> >[] { x => x.FirstName, x => x.LastName },
ErrorMessageText);
Assert.IsTrue(validatorByNames.Validate(fullyValidData.Collection).IsValid);
Assert.IsTrue(validatorByNames.Validate(duplicatedIdData.Collection).IsValid);
Assert.IsTrue(validatorByNames.Validate(duplicatedLastNameData.Collection).IsValid);
result = validatorByNames.Validate(duplicatedNamesData.Collection);
Assert.IsFalse(result.IsValid);
equals = duplicatedNamesData.IsActualDuplicatesCorrect(
((UniqueValidationResult)result.First()).DuplicatedItems);
Assert.IsTrue(equals);
expectedErrorMessage = ErrorMessageText;
actualErrorMessage = result.First().ErrorMessage;
Assert.AreEqual(expectedErrorMessage, actualErrorMessage);
}
public void CanValidateUsingDefaultEqualityComparer()
{
var validTstingData = TestingDataFactory.Unique.CreateSimpleUniqueData();
var invalidTestingData = TestingDataFactory.Unique.CreateSimpleNotUniqueData();
var myStringCollectionValidator = new UniqueValidator <string>();
var result = myStringCollectionValidator.Validate(validTstingData.Collection);
Assert.IsTrue(result.IsValid);
result = myStringCollectionValidator.Validate(invalidTestingData.Collection);
Assert.IsFalse(result.IsValid);
var equals = invalidTestingData.IsActualDuplicatesCorrect(
((UniqueValidationResult)result.First()).DuplicatedItems);
Assert.IsTrue(equals);
}
/// <summary>
/// Показує ділогове вікно для введеня ім"я критерію чи альтернативи
/// </summary>
/// <param name="nameKind">Критерій/Альтернатива</param>
/// <returns>Введене ім"я альтернативи чи критерію</returns>
private string _showNameEditor(EntityKind nameKind)
{
frmNameEdit frmNameEditor = new frmNameEdit( );
frmNameEditor.Init(nameKind);
frmNameEditor.Validating += delegate(object sender, EventArgs <IValidationResult> e)
{
List <string> validationInfo = new List <string> ( );
IEnumerable items;
items = nameKind == EntityKind.Alternative ? ctrlMatrix.Alternatives
: ctrlMatrix.Criteriums;
foreach (object item in items)
{
validationInfo.Add(item.ToString( ));
}
UniqueValidator <string> uniqueValidator = new UniqueValidator <string> (validationInfo.ToArray( ), frmNameEditor.Value);
e.Value = uniqueValidator.Validate( );
};
return(frmNameEditor.ShowDialog( ) == DialogResult.OK ? frmNameEditor.Value : string.Empty);
}
public void DataValidation(BudgetProgressChangedEventHandler OnProgress, List <CurrencyEntity> entityList)
{
if (entityList == null || entityList.Count == 0)
{
return;
}
//List<CategoryEntity> categoryDBList = GetAllCategoryDataFromDB(OnProgress);
//var categoryCodeDBList = from item in categoryDBList
// select item.CategoryCode;
//ListRangeValidator<string> categoryCodelistRangeValidator = new ListRangeValidator<string>(categoryCodeDBList.ToList<string>(), BudgetResource.Message.Currency_CategoryCode_NoExist);
List <CurrencyEntity> currencyDBList = GetDataFromDB(OnProgress);
var currencyCodeDBList = from item in currencyDBList
select item.CurrencyCode;
ListRangeValidator <string> currencyCodeListRangeValidator = new ListRangeValidator <string>(currencyCodeDBList.ToList <string>(), true, BudgetResource.Message.Currency_CurrencyCode_Exists);
var currencyCodeList = from item in entityList
select item.CurrencyCode;
UniqueValidator <string> UniqueValidator = new UniqueValidator <string>(currencyCodeList.ToList <string>(), BudgetResource.Message.Currency_CurrencyCode_Unique);
ValidatorFactory valFactory = EnterpriseLibraryContainer.Current.GetInstance <ValidatorFactory>();
Validator <CurrencyEntity> entityValidator = valFactory.CreateValidator <CurrencyEntity>();
int i = 1;
bool noError = true;
int count = entityList.Count();
StringBuilder builder = new StringBuilder();
foreach (CurrencyEntity entity in entityList)
{
ValidationResults results = entityValidator.Validate(entity);
//ValidationResults categoryExistCheckResults = categoryCodelistRangeValidator.Validate(entity.CategoryCode);
//results.AddAllResults(categoryExistCheckResults);
if (!entity.ReadOnly)
{
ValidationResults currencyExistCheckResults = currencyCodeListRangeValidator.Validate(entity.CurrencyCode);
results.AddAllResults(currencyExistCheckResults);
}
ValidationResults uniqueCheckResult = UniqueValidator.Validate(entity.CurrencyCode);
results.AddAllResults(uniqueCheckResult);
bool isValid = results.IsValid;
noError &= isValid;
if (!isValid)
{
builder.AppendLine(
string.Format(
CultureInfo.CurrentCulture,
BudgetResource.Message.Common_Row_Error,
entity.Row));
foreach (ValidationResult result in results)
{
builder.AppendLine(
string.Format(
CultureInfo.CurrentCulture,
BudgetResource.Message.Common_Field_Error,
result.Message));
}
}
if (OnProgress != null)
{
string InfomationMessage = string.Format("you are validating No. {0} data", i);
int Percentage = (int)(i * BudgetConstant.ProgressBarMaximum / count);
BudgetProgressChangedEventArgs args = new BudgetProgressChangedEventArgs(InfomationMessage, Percentage, null);
OnProgress(this, args);
}
i++;
}
if (!noError)
{
throw new BudgetRuntimeException("Validation Error", builder.ToString());
}
}
public void DataValidation(ProjectAllocationFramework.Statues.ProgressChangedEventHandler OnProgress, List <WorkerEntity> entityList)
{
if (entityList == null || entityList.Count == 0)
{
return;
}
List <WorkerEntity> userDBList = GetDataFromDB(OnProgress);
var WorkerCodeDBList = from item in userDBList
select item.WorkerCode;
ListRangeValidator <string> WorkerCodeListRangeValidator = new ListRangeValidator <string>(WorkerCodeDBList.ToList <string>(), true, ProjectAllocationResource.Message.Worker_WorkerCode_Exists);
var WorkerCodeList = from item in entityList
select item.WorkerCode;
UniqueValidator <string> UniqueValidator = new UniqueValidator <string>(WorkerCodeList.ToList <string>(), ProjectAllocationResource.Message.Worker_WorkerCode_Unique);
ValidatorFactory valFactory = EnterpriseLibraryContainer.Current.GetInstance <ValidatorFactory>();
Validator <WorkerEntity> entityValidator = valFactory.CreateValidator <WorkerEntity>();
int i = 1;
bool noError = true;
int count = entityList.Count();
StringBuilder builder = new StringBuilder();
foreach (WorkerEntity entity in entityList)
{
ValidationResults results = entityValidator.Validate(entity);
if (!entity.ReadOnly)
{
ValidationResults userExistCheckResults = WorkerCodeListRangeValidator.Validate(entity.WorkerCode);
results.AddAllResults(userExistCheckResults);
}
ValidationResults uniqueCheckResult = UniqueValidator.Validate(entity.WorkerCode);
results.AddAllResults(uniqueCheckResult);
bool isValid = results.IsValid;
noError &= isValid;
if (!isValid)
{
builder.AppendLine(
string.Format(
CultureInfo.CurrentCulture,
ProjectAllocationResource.Message.Common_Row_Error,
entity.Row));
foreach (ValidationResult result in results)
{
builder.AppendLine(
string.Format(
CultureInfo.CurrentCulture,
ProjectAllocationResource.Message.Common_Field_Error,
result.Message));
}
}
if (OnProgress != null)
{
string InfomationMessage = string.Format(ProjectAllocationResource.Message.Common_Master_Validate_Info, i);
int Percentage = (int)(i * Constant.ProgressBarMaximum / count);
ProjectAllocationFramework.Statues.ProgressChangedEventArgs args = new ProjectAllocationFramework.Statues.ProgressChangedEventArgs(InfomationMessage, Percentage, null);
OnProgress(this, args);
}
i++;
}
if (!noError)
{
throw new ProjectAllocationFramework.RuntimeException("Validation Error", builder.ToString());
}
}
