If you need to assert the values of several object properties in one logical step, the Fixture.VerifyPropertiesOf<T>()
method is a helper to quickly put together a paragraph grammer to verify multiple properties.
Using the same Address
type from the previous section (Configuring Input Models with ModelFixture), you could build a grammar like this one:
public IGrammar TheAddressShouldBe()
{
return VerifyPropertiesOf<Address>("then the new address properties should be", x =>
{
x.Check(o => o.Address1);
x.Check(o => o.Address2);
x.Check(o => o.City);
});
}
In usage, a specification using that grammar will render results like this below:
Using VerifyProperties
Address Setup
If the new address is
then the new address properties should be
You can use multiple "dots" in the call to Check(expression)
and even verify the result of a method with no arguments. So Check(o => o.Property1.Property2.Property3)
or Check(o => o.IsActive())
are both valid. As of now, only properties and methods are supported. Support for fields will be added later.
CheckModelFixture
New in Storyteller 4.2 is a helper Fixture
class called CheckModelFixture
that smoothes out a little bit of friction in
creating a Fixture that needs to make several assertions against the state of a model object.
Here's an example against a simple Address DTO:
public class ModelForwardingFixture : CheckModelFixture<Address>
{
public ModelForwardingFixture()
{
Title = "Build and Verify Address";
// You can customize the Cell editing and appearance
// of any of the automatically generated grammars by
// property or field name. The expression can be deep as
// well
For(x => x.City).Header("The city");
// The Model property is an easy way to set the current Address model
// that should be verified by all the children grammars
Model = new Address();
}
public IGrammar BuildAddress()
{
// This is a new 4.2 helper to build a model object
// with an embedded section and use that object within
// the containing Fixture
return Build<Address>("If the address is")
.With<AddressModelFixture>()
.Forward(a => Model = a);
}
}
Without doing anything else, CheckModelFixture<T>
will add grammars to verify the values of all public properties or fields of
the model type ("T"). To some degree, CheckModelFixture<T>
can also guess at deeper properties or fields on intermediate objects. For example, if your Address
had an Area
property that in turn exposed properties:
public class Address
{
public string Address1 { get; set; }
public string Address2 { get; set; }
public string City { get; set; }
public string StateOrProvince { get; set; }
public string Country { get; set; }
public string PostalCode { get; set; }
public string TimeZone { get; set; }
public double DistanceFromOffice { get; set; }
public string[] Names { get; set; }
public string County;
public Area Area { get; set; }
}
public class Area
{
public string Name;
}
CheckModelFixture<Address>
would be smart enough to add a grammar to check the value of the Address.Area.Name
property. Do note that the auto-discovery of grammar's does apply to Array
types, but any property or field that returns a different enumerable of any kind is not automatically used. There's nothing
stopping you from adding additional grammars to your own CheckModelFixture<T>
to verify child collections of the model.