public void ValidationIsPerformedOnCollectionElementsUsingSuppliedRuleset()
{
object instance1 = new ObjectCollectionValidatorFixtureReferencedTestClass();
object instance2 = new ObjectCollectionValidatorFixtureReferencedTestClass();
object target = new object[] { instance1, instance2 };
Validator validator = new ObjectCollectionValidator(typeof(ObjectCollectionValidatorFixtureReferencedTestClass), "RuleB");
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, this, "key", validationResults); // setting the currentTarget and the key
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(2, resultsList.Count);
Assert.AreEqual("PropertyInReferencedObject-RuleB", resultsList[0].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[0].Key);
Assert.AreEqual(null, resultsList[0].Tag);
Assert.AreSame(instance1, resultsList[0].Target);
Assert.AreEqual("PropertyInReferencedObject-RuleB", resultsList[1].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Key);
Assert.AreEqual(null, resultsList[1].Tag);
Assert.AreSame(instance2, resultsList[1].Target);
}
public void ValidationOfNullLogsNoError()
{
Validator validator = new ObjectCollectionValidator(typeof(ObjectCollectionValidatorFixtureReferencedTestClass));
ValidationResults validationResults = validator.Validate(null);
Assert.IsTrue(validationResults.IsValid);
}
public void ValidationOfCollectionWithNullLogsNoError()
{
object target = new ObjectCollectionValidatorFixtureReferencedTestClass[] { null };
Validator validator = new ObjectCollectionValidator(typeof(ObjectCollectionValidatorFixtureReferencedTestClass));
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, this, "key", validationResults); // setting the currentTarget and the key
Assert.IsTrue(validationResults.IsValid);
}
public void ValidatesUsingTheRulesForTheActualTypeIfValidatingTheActualType()
{
// TODO - change to avoid relying on reflection order
object instance1 = new ObjectCollectionValidatorFixtureReferencedTestClass();
object instance2 = new DerivedObjectCollectionValidatorFixtureReferencedTestClass();
object target = new object[] { instance1, instance2 };
Validator validator = new ObjectCollectionValidator();
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, this, "key", validationResults); // setting the currentTarget and the key
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(6, resultsList.Count);
Assert.AreEqual("ReferencedObject", resultsList[0].Message);
Assert.AreEqual(null, resultsList[0].Key);
Assert.AreEqual(null, resultsList[0].Tag);
Assert.AreSame(instance1, resultsList[0].Target);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Key);
Assert.AreEqual(null, resultsList[1].Tag);
Assert.AreSame(instance1, resultsList[1].Target);
Assert.AreEqual("DerivedReferencedObject", resultsList[2].Message);
Assert.AreEqual(null, resultsList[2].Key);
Assert.AreEqual(null, resultsList[2].Tag);
Assert.AreSame(instance2, resultsList[2].Target);
Assert.AreEqual("PropertyInDerivedReferencedObject", resultsList[3].Message);
Assert.AreEqual("PropertyInDerivedReferencedObject", resultsList[3].Key);
Assert.AreEqual(null, resultsList[3].Tag);
Assert.AreSame(instance2, resultsList[3].Target);
Assert.AreEqual("PropertyInReferencedObject", resultsList[4].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[4].Key);
Assert.AreEqual(null, resultsList[4].Tag);
Assert.AreSame(instance2, resultsList[4].Target);
Assert.AreEqual("PropertyInDerivedReferencedObject-DataAnnotations", resultsList[5].Message);
Assert.AreEqual("PropertyInDerivedReferencedObject", resultsList[5].Key);
Assert.AreEqual(null, resultsList[5].Tag);
Assert.AreSame(instance2, resultsList[5].Target);
}
public void ValidationOfCollectionWithObjectsOfNonCompatibleTypeLogsError()
{
object target = new object[] { 10 };
Validator validator = new ObjectCollectionValidator(typeof(ObjectCollectionValidatorFixtureReferencedTestClass));
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, this, "key", validationResults); // setting the currentTarget and the key
Assert.IsFalse(validationResults.IsValid);
IDictionary <string, ValidationResult> resultsMapping = ValidationTestHelper.GetResultsMapping(validationResults);
Assert.AreEqual(1, resultsMapping.Count);
Assert.IsTrue(resultsMapping.ContainsKey(Resources.ObjectCollectionValidatorIncompatibleElementInTargetCollection));
Assert.AreEqual(null, resultsMapping[Resources.ObjectCollectionValidatorIncompatibleElementInTargetCollection].Key);
Assert.AreEqual(null, resultsMapping[Resources.ObjectCollectionValidatorIncompatibleElementInTargetCollection].Tag);
Assert.AreEqual(10, resultsMapping[Resources.ObjectCollectionValidatorIncompatibleElementInTargetCollection].Target);
Assert.AreSame(validator, resultsMapping[Resources.ObjectCollectionValidatorIncompatibleElementInTargetCollection].Validator);
}
static void ValidatingACollectionOfObjects()
{
// Create a collection of two objects, one with valid values and one with invalid values.
List <IProduct> productList = new List <IProduct>();
Product validProduct = new Product();
PopulateValidProduct(validProduct);
productList.Add(validProduct);
Product invalidProduct = new Product();
PopulateInvalidProduct(invalidProduct);
productList.Add(invalidProduct);
Console.WriteLine("Created and populated a collection of the Product class.");
// Create an Object Collection Validator for the collection type.
Validator collValidator = new ObjectCollectionValidator(typeof(Product));
// Validate all of the objects in the collection.
ValidationResults results = collValidator.Validate(productList);
// Display the results.
ShowValidationResults(results);
}
public void NullElementsInCollectionAreSkipped()
{
object instance1 = new ObjectCollectionValidatorFixtureReferencedTestClass();
object instance2 = new ObjectCollectionValidatorFixtureReferencedTestClass();
object target = new object[] { instance1, null, instance2 };
Validator validator = new ObjectCollectionValidator(typeof(ObjectCollectionValidatorFixtureReferencedTestClass));
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, this, "key", validationResults); // setting the currentTarget and the key
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(4, resultsList.Count);
Assert.AreEqual("ReferencedObject", resultsList[0].Message);
Assert.AreEqual(null, resultsList[0].Key);
Assert.AreEqual(null, resultsList[0].Tag);
Assert.AreSame(instance1, resultsList[0].Target);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[1].Key);
Assert.AreEqual(null, resultsList[1].Tag);
Assert.AreSame(instance1, resultsList[1].Target);
Assert.AreEqual("ReferencedObject", resultsList[2].Message);
Assert.AreEqual(null, resultsList[2].Key);
Assert.AreEqual(null, resultsList[2].Tag);
Assert.AreSame(instance2, resultsList[2].Target);
Assert.AreEqual("PropertyInReferencedObject", resultsList[3].Message);
Assert.AreEqual("PropertyInReferencedObject", resultsList[3].Key);
Assert.AreEqual(null, resultsList[3].Tag);
Assert.AreSame(instance2, resultsList[3].Target);
}
public Response <Model.Customer> Create(Model.Customer customer)
{
ICustomerRepository customerRepository = null;
IAddressRepository addressRepository = null;
Validator <Model.Customer> validator = ValidationFactory.CreateValidator <Model.Customer>("Create");
Validator validatorAddress = new ObjectCollectionValidator(typeof(Model.Address), "Create");
try
{
#region Validation
if (!validator.Validate(customer).IsValid)
{
response.Status = ResponseStatus.ErrorValidation;
response.ErrorValue = (int)ErrorCode.InvalidData;
foreach (var result in validator.Validate(customer))
{
if (!response.Validations.ContainsKey(result.Key))
{
response.Validations.Add(result.Key, result.Message);
}
}
return(response);
}
if (customer.Addresses.IsNullOrEmpty())
{
response.Status = ResponseStatus.ErrorValidation;
response.ErrorValue = (int)ErrorCode.InvalidData;
response.Validations.Add("Address", "Address must have at least one");
return(response);
}
else
{
if (!validatorAddress.Validate(customer.Addresses).IsValid)
{
response.Status = ResponseStatus.ErrorValidation;
response.ErrorValue = (int)ErrorCode.InvalidData;
foreach (var result in validatorAddress.Validate(customer.Addresses))
{
if (!response.Validations.ContainsKey(result.Key))
{
response.Validations.Add(result.Key, result.Message);
}
}
return(response);
}
else // Validate Email
{
foreach (Model.Address address in customer.Addresses)
{
if (!address.PrimaryEmail.IsNullOrEmpty())
{
Validator <Model.Address> valEmail = ValidationFactory.CreateValidator <Model.Address>("Email");
if (!valEmail.Validate(address).IsValid)
{
response.Status = ResponseStatus.ErrorValidation;
response.ErrorValue = (int)ErrorCode.InvalidData;
foreach (var result in valEmail.Validate(address))
{
if (!response.Validations.ContainsKey(result.Key))
{
response.Validations.Add(result.Key, result.Message);
}
}
return(response);
}
}
}
}
}
#endregion Validation
#region Create
using (var ctx = new ChickenScratchContext())
{
// Set default
customer.Status = "A";
customer.TokenSecret = Guid.NewGuid().ToString();
customer.FromDate = DateTime.UtcNow;
customer.ToDate = DateTime.UtcNow.AddYears(1);
// Create Customer
customerRepository = new CustomerRepository(ctx);
customerRepository.Add(customer);
// Create Adrress
addressRepository = new AddressRepository(ctx);
addressRepository.Inserts(customer.Addresses);
customerRepository.Save();
response.Result = customer;
response.Status = ResponseStatus.Success;
}
#endregion Create
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Method to get validation results for collection of attribute driven class
/// </summary>
/// <typeparam name="T">Generic type</typeparam>
/// <param name="items">collection of item</param>
/// <returns>returns validation result</returns>
public static ValidationResults GetValidationResult <T>(List <T> items) where T : class
{
Validator collectionValidator = new ObjectCollectionValidator(typeof(T));
return(collectionValidator.Validate(items));
}
