public void Validate_Collection_Using_Specified_Specification_WithoutValidateObjectGraph()
{
//Build test data
var validContact = new Contact()
{
FirstName = "Johnny B", LastName = "Good"
};
var invalidContact = new Contact()
{
FirstName = "Baddy"
};
var contacts = new List <Contact>()
{
validContact, invalidContact
};
//Create specification
ValidationCatalog.AddSpecification <Contact>(spec =>
{
spec.Check(c => c.FirstName).Required();
spec.Check(c => c.LastName).Required();
});
//Validate
var results = ValidationCatalog.Validate(contacts);
Assert.That(results.Errors.Count, Is.AtLeast(1));
}
public void ValidateConcurrently()
{
ValidationCatalog.AddSpecification <Customer>(s => s.Check(c => c.Name).Required().MaxLength(50));
Customer customer1 = new Customer()
{
Name = string.Empty.PadLeft(55, 'X')
};
Customer customer2 = new Customer()
{
Name = string.Empty.PadLeft(45, 'X')
};
var childThread = new Thread(() =>
{
var customer1Notification = ValidationCatalog.Validate(customer1);
Assert.IsFalse(customer1Notification.IsValid);
});
childThread.Start();
var customer2Notification = ValidationCatalog.Validate(customer2);
Assert.IsTrue(customer2Notification.IsValid);
childThread.Join();
}
public void ValidateMethodCallPropertyOnClass_IsSuccessful()
{
ValidationCatalog.AddSpecification <StubClass>(validates => validates.Check(x => x.GetCollection()).Required().CountGreaterThan(1));
var c = new StubClass();
Assert.DoesNotThrow(() => ValidationCatalog.Validate(c));
}
public void SpecificationAbstract_OnObject_WithSpecification_IsValid()
{
ValidationCatalog.AddSpecification <BaseClassSpecification>();
ValidationCatalog.AddSpecification <DerivedClassASpecification>();
ValidationCatalog.AddSpecification <DerivedClassBSpecification>();
ValidationCatalog.AddSpecification <ClassWithAbstractPropertySpecification>();
var t = new DerivedClassA();
var a = new ClassWithAbstractProperty {
BaseClassProperty = t
};
//collection
a.BaseClassCollectionProperty = new List <BaseClass>();
//a.BaseClassCollectionProperty.Add(new DerivedClassA());
a.BaseClassCollectionProperty.Add(new DerivedClassB()
{
BaseName = "Valid"
});
var n = ValidationCatalog.Validate(a);
Assert.That(n.IsValid, Is.False);
Assert.That(n.All().Count(), Is.EqualTo(3));
}
public void When_WithMessageIsSuppliedWithCustomPropetyValueFormat()
{
var customMessage = "Dope! It's required!";
//Add a rule
ValidationCatalog.AddSpecification <Contact>(
spec => spec.Check(c => c.DateOfBirth).Required()
.IsInPast().With(m =>
{
m.Message =
"Date must be in the past. You entered {PropertyValue}.";
m.FormatProperty = s => s.ToShortDateString();
}));
//String.Format("{0} must be less than {1}", m.PropertyName, m.PropertyValue.ToString("mm/dd/yyyy"))));
//dummy data
var contact = new Contact()
{
FirstName = "Joesph", LastName = "Smith", DateOfBirth = System.DateTime.Now.AddYears(1)
};
//Validate
var valNot = ValidationCatalog.Validate(contact);
Assert.That(valNot.Errors, Is.Not.Empty);
Assert.That(valNot.Errors.First().Message, Is.EqualTo("Too long 5"));
}
public void When_validated_with_ExplicitSpecification()
{
//Don't implicitly validate object graph
ValidationCatalog.ValidateObjectGraph = false;
var customer = new Customer {
Name = "SampleCustomer", Address = new Address()
{
Country = new Country()
{
Id = "DE", Name = "Germany"
}, Street = "1234 Offenbacher Strasse"
}
};
//Add Specification for Customer for international addresses
ValidationCatalog.SpecificationContainer.Add(new InternationalAddressSpecification());
ValidationCatalog.AddSpecification <Customer>(spec => spec.Check(c => c.Address).Required().Specification <InternationalAddressSpecification>());
//Validate Customer
var results = ValidationCatalog.Validate(customer);
Assert.That(results.Errors, Is.Not.Empty);
Assert.That(results.Errors.First().NestedValidationResults, Is.Not.Empty);
}
public void Validate_Property_With_NullCondition_IsValid()
{
// String.IsNullOrEmpty(c.Addresses[0].City) should throw an exception
ValidationCatalog.AddSpecification <Contact>(spec => spec.Check(c => c.FirstName).If(c => String.IsNullOrEmpty(c.Addresses[0].City)).Required());
var vn = ValidationCatalog.Validate(new Contact());
Assert.That(vn.IsValid, Is.True);
}
public void SpecificationInheritance_OnObject_WithSpecification_IsValid()
{
ValidationCatalog.AddSpecification <BaseClassSpecification>();
ValidationCatalog.AddSpecification <DerivedClassASpecification>();
var a = new DerivedClassA();
var n = ValidationCatalog.Validate(a);
Assert.That(n.IsValid, Is.False);
Assert.That(n.All().Count(), Is.EqualTo(2));
}
public void Validate_OptionalNestedProperty_WithNullValue_IsValid()
{
var customer = new Customer();
ValidationCatalog.AddSpecification <Customer>(spec => spec.Check(cust => cust.Address.Street).Optional()
.MaxLength(255));
var results = ValidationCatalog.Validate(customer);
Assert.That(results.Errors, Is.Empty);
}
public void InvalidExpression_IsInvalid()
{
ValidationCatalog.AddSpecification <Contact>(x => x.Check(c => c.NumberOfDependents).Required().
GreaterThan(z => new BadWolf().Max(z.NumberOfDependents)));
var contact = new Contact()
{
LastName = "Bill"
};
var results = ValidationCatalog.Validate(contact);
Assert.That(results.Errors, Is.Not.True);
}
public void Enum_ValueIsFirstValue_IsRequired()
{
ValidationCatalog.AddSpecification <Person>(spec =>
spec.Check(p => p.PersonGender).Required());
var person = new Person()
{
PersonGender = Gender.Male
};
var vn = ValidationCatalog.Validate(person);
Assert.That(vn.IsValid, Is.True);
}
public bool IsValid()
{
ValidationCatalog.AddSpecification <Contact>(x =>
{
x.Check(contact => contact.LastName).Required();
x.Check(contact => contact.FirstName).Required();
x.Check(contact => contact.DateOfBirth).Optional().
GreaterThan(new DateTime(1950, 1, 1));
});
//Validate
Errors = ValidationCatalog.Validate(this);
return(Errors.IsValid);
}
public void ForEachSpecification_Warn_IsValid()
{
//Don't implicitly validate object graph
ValidationCatalog.ValidateObjectGraph = false;
//create list of contacts to validate
var contacts = new List <Contact>
{
new Contact()
{
FirstName = String.Empty, LastName = "Smith"
},
new Contact()
{
FirstName = String.Empty, LastName = String.Empty
},
new Contact()
{
FirstName = "Joe", LastName = "Smith"
}
};
var customer = new Customer()
{
Name = "Smith Industries", Contacts = contacts
};
//Add Specification for Customer and Address
ValidationCatalog.AddSpecification <Customer>(spec =>
{
spec.Check(c => c.Contacts).Required();
spec.Warn(c => c.Contacts).Optional().ForEachSpecification <Contact>(
cspec =>
{
cspec.Warn(c => c.LastName).Required();
cspec.Warn(c => c.FirstName).Required();
});
});
//Validate Customer
var results = ValidationCatalog.Validate(customer);
Assert.That(results.Errors, Is.Not.Empty);
Assert.IsTrue(results.IsValid);
var allerrors = results.Errors.First().AllErrorMessages().ToList();
Assert.That(results.Errors.First().NestedValidationResults, Is.Not.Empty);
}
public void ValidationNotification_WithOneError_IsValid()
{
ValidationCatalog.AddSpecification <Customer>(spec =>
{
spec.Check(c => c.Name).Required();
spec.Warn(c => c.Address).Required().Specification <AddressSpecification>();
});
var customer = new Customer();
var vn = ValidationCatalog.Validate(customer);
Assert.That(vn.IsValid, Is.False);
}
public void Validate_Property_Label_Is_Available_On_Error_When_Invalid()
{
const string expected = "This is a custom rule label";
ValidationCatalog.AddSpecification <Contact>(spec =>
spec.Check(c => c.FirstName).WithLabel(expected).Required());
var contact = new Contact();
var vn = ValidationCatalog.Validate(contact);
Assert.That(vn.IsValid, Is.False);
var error = vn.Errors.Single();
Assert.AreEqual(expected, error.Label);
}
public void Validate_Property_With_CustomName_IsValid_And_Label_Is_Set()
{
const string expected = "This is a custom rule label";
ValidationCatalog.AddSpecification <Contact>(spec =>
spec.Check(c => c.FirstName).WithLabel(expected)
.If(c => String.IsNullOrEmpty(c.Addresses[0].City)).Required());
var vn = ValidationCatalog.Validate(new Contact());
Assert.That(vn.IsValid, Is.True);
var actual = ValidationCatalog.SpecificationContainer.GetAllSpecifications().Single().PropertyValidators.Single().Label;
Assert.AreEqual(expected, actual);
}
public void When_MessageContainsParameters()
{
ValidationCatalog.AddSpecification <Contact>(
spec => spec.Check(c => c.LastName).Required().EqualTo("Johnson"));
//dummy data
var contact = new Contact()
{
FirstName = "Joesph", LastName = "Smith"
};
//Validate
var valNot = ValidationCatalog.Validate(contact);
Assert.That(valNot.Errors, Is.Not.Empty);
Assert.That(valNot.Errors.First().Message, Is.EqualTo("Last Name must equal Johnson."));
}
public void When_WithMessageKeyIsSupplied_DefaultMessageIsOverridden()
{
//Add a rule
ValidationCatalog.AddSpecification <Contact>(spec => spec.Check(c => c.LastName).Required().
LengthBetween(1, 3).With(m => m.MessageKey = "Alpha"));
//dummy data
var contact = new Contact()
{
FirstName = "Joesph", LastName = "Smith"
};
//Validate
var valNot = ValidationCatalog.Validate(contact);
Assert.That(valNot.Errors, Is.Not.Empty);
Assert.That(valNot.Errors.First().Message, Is.EqualTo("Last Name should only contain letters."));
}
public void ValidateProperty_NoValidationForProperty_ThrowsArgumentException()
{
//Create Rules Adhoc
ValidationCatalog.AddSpecification <Contact>(x =>
{
x.Check(c => c.FirstName).Required();
});
var contact = new Contact();
// Validation contact.LastName should result with only one error.
Assert.Throws <ArgumentException>(
() =>
{
var propertyNotification = ValidationCatalog.ValidateProperty(contact, c => c.LastName);
});
}
public void NullableEnum_ValueIsSecondValue_IsRequired()
{
ValidationCatalog.AddSpecification <Person>(spec =>
{
spec.Check(p => p.PersonGender).Required();
spec.Check(p => p.NullablePersonGender).Required();
}
);
var person = new Person()
{
PersonGender = Gender.Female
};
var vn = ValidationCatalog.Validate(person);
Assert.That(vn.IsValid, Is.False);
Assert.That(vn.Errors.First().Message, Is.EqualTo("Nullable Person Gender is required."));
}
public void Validate_OptionalCollection_Using_Registered_Specification()
{
//Build test data
var customer = new Customer()
{
Name = "TestCustomer"
};
var validContact = new Contact()
{
FirstName = "Johnny B", LastName = "Good"
};
var invalidContact = new Contact()
{
FirstName = "Baddy"
};
customer.Contacts = new List <Contact>()
{
validContact, invalidContact
};
//Build specifications
ValidationCatalog.AddSpecification <Customer>(spec =>
{
spec.Check(cust => cust.Name).Required();
spec.Check(cust => cust.Contacts).Required();
});
ValidationCatalog.AddSpecification <Contact>(spec =>
{
spec.Check(c => c.FirstName).Required();
spec.Check(c => c.LastName).Required();
});
ValidationCatalog.ValidateObjectGraph = true;
//Validate
var results = ValidationCatalog.Validate(customer);
Assert.That(results.Errors.Count, Is.AtLeast(1));
}
public void TryGetSpecification_WithMock_ReturnsSpecification()
{
//Add the target specification to the container
ValidationCatalog.AddSpecification <Contact>(x => new ContactSpecification());
//create the mock object which is proxy type
var mockRepository = new MockRepository();
mockRepository.Record();
Contact contact = mockRepository.DynamicMock <Contact>();
SetupResult.For(contact.FirstName).Return("Something");
SetupResult.For(contact.LastName).Return("Else");
mockRepository.ReplayAll();
//Get a specification that matches the underlying type for the proxy
var specification = ValidationCatalog.SpecificationContainer.TryGetSpecification(contact.GetType());
Assert.That(specification, Is.Not.Null);
}
public void GetMessageForRuleWithMessageOverrrideAndMessageKey()
{
ValidationCatalog.Configure(x => x.AddMessageStore(new ResourceMessageStore(TestRuleErrorMessages.ResourceManager), "OverrideMessages"));
ValidationCatalog.AddSpecification <Contact>(c =>
{
c.Check(x => x.LastName).Required().IsAlpha().With(m => m.MessageKey = "TestRule");
}
);
//Create an Entity
var contact = new Contact();
contact.FirstName = null;
contact.LastName = "1111";
var results = ValidationCatalog.ValidateProperty(contact, c => c.LastName);
Assert.That(results.Errors.ToList().First().Message == "Last Name is invalid!");
}
public void When_WithMessageIsSupplied_DefaultMessageIsOverridden()
{
var customMessage = "Dope! It's required!";
//Add a rule
ValidationCatalog.AddSpecification <Contact>(spec => spec.Check(c => c.LastName).Required().
LengthBetween(1, 3).With(m => m.Message = "Too long {PropertyValue}"));
//dummy data
var contact = new Contact()
{
FirstName = "Joesph", LastName = "Smith"
};
//Validate
var valNot = ValidationCatalog.Validate(contact);
Assert.That(valNot.Errors, Is.Not.Empty);
Assert.That(valNot.Errors.First().Message, Is.EqualTo("Too long 5"));
}
public void Specification_WithForEachSpecification_UsingValidationCatalog_Assert_ThrowsException()
{
//Add spec to catalog
ValidationCatalog.AddSpecification <PersonSpecification>();
//Setup test data
_persons.Add(new Person()
{
FirstName = "First", LastName = "Last"
});
_persons.Add(new Person()
{
FirstName = "First"
}); //Missing Last Name
Assert.Throws <ValidationException>(() =>
{
Specification.Assert(sp => sp.Check(s => _persons).Required().ForEachSpecification());
});
}
public void SpecificationInheritance_OnObject_WithSpecification_IsValid()
{
//Base Class
ValidationCatalog.SpecificationContainer.Add(new CustomerRequiredNameSpecification());
//Inherited class
ValidationCatalog.AddSpecification <ExtendedCustomer>(spec =>
{
spec.Using <Customer, CustomerRequiredNameSpecification>();
spec.Check(c => c.SpecialGreeting).Required();
});
var customer = new ExtendedCustomer();
var results = ValidationCatalog.Validate(customer);
Assert.That(results.Errors.Count, Is.EqualTo(2));
var errorMessages = results.Errors.Select(x => x.ToString());
Assert.That(errorMessages.Contains("Cust Name is required."));
Assert.That(errorMessages.Contains("Special Greeting is required."));
}
public void ValidateProperty_SimpleProperty_OverridePropertyNameReturnsValidationNotification()
{
//Create Rules Adhoc
ValidationCatalog.AddSpecification <Contact>(x =>
{
x.Check(c => c.LastName, "Contact Last Name").Required();
x.Check(c => c.FirstName).Required();
});
var contact = new Contact();
// Validating contact as a whole should result in two errors.
var objectNotification = ValidationCatalog.Validate(contact);
Assert.IsFalse(objectNotification.IsValid);
Assert.AreNotEqual(2, objectNotification.Errors);
// Validation contact.LastName should result with only one error.
var propertyNotification = ValidationCatalog.ValidateProperty(contact, c => c.LastName);
Assert.IsFalse(propertyNotification.IsValid);
Assert.AreNotEqual(1, propertyNotification.Errors);
}
public void ValidationContainer_Initialize()
{
//Create Rules Adhoc
ValidationCatalog.AddSpecification <Contact>(x =>
{
x.Check(contact => contact.LastName).Required();
x.Check(contact => contact.FirstName).Required();
x.Check(contact => contact.DateOfBirth).Optional()
.GreaterThan(
new DateTime(1950, 1, 1));
});
//Dummy Contact
var emptyContact = new Contact();
emptyContact.FirstName = null;
emptyContact.LastName = null;
//Validate
ValidationNotification notification = ValidationCatalog.Validate(emptyContact);
Assert.That(notification.Errors, Is.Not.Empty);
}
public void When_multiple_specifications_defined_with_default_spec_defined_return_default()
{
Assembly assembly = Assembly.LoadFrom("SpecExpress.Test.Domain.dll");
ValidationCatalog.Scan(x => x.AddAssembly(assembly));
//Add Default specification with optional last name
ValidationCatalog.AddSpecification <SpecExpress.Test.Domain.Entities.Contact>(spec =>
{
spec.IsDefaultForType();
spec.Check(c => c.LastName).Optional();
});
//Add Secondary specification with required last name
ValidationCatalog.AddSpecification <SpecExpress.Test.Domain.Entities.Contact>(spec => spec.Check(c => c.LastName).Required());
//Create valid object, with null Last Name
var contact = new SpecExpress.Test.Domain.Entities.Contact();
var vn = ValidationCatalog.Validate(contact);
Assert.That(vn.IsValid, Is.True);
}
public void ValidateProperty_CollectionProperty_ReturnsValidationNotification()
{
//Create Rules Adhoc
ValidationCatalog.AddSpecification <Address>(x =>
{
x.Check(a => a.Street)
.Required()
.MaxLength(50);
});
ValidationCatalog.AddSpecification <Contact>(x =>
{
x.Check(c => c.Addresses).Required()
.ForEachSpecification <Address>();
x.Check(c => c.FirstName).Required().MaxLength(100);
});
var contact = new Contact();
contact.Addresses = new List <Address>()
{
new Address()
};
// Validating contact as a whole should result in two errors.
var objectNotification = ValidationCatalog.Validate(contact);
Assert.IsFalse(objectNotification.IsValid);
Assert.AreEqual(2, objectNotification.Errors.Count);
// Validation contact.LastName should result with only one error.
var propertyNotification = ValidationCatalog.ValidateProperty(contact, c => c.Addresses);
Assert.IsFalse(propertyNotification.IsValid);
Assert.AreEqual(1, propertyNotification.Errors.Count);
}