Setting Property Values While Building Anonymous Variables With AutoFixture by Mark Seemann
In my previous post I described how the Build method can be used to customize how a single anonymous variable is created.
A common customization is to set a property value during creation. In most cases, this can simply be done after the anonymous variable has been created (so the following is not an AutoFixture customization):
var mc = fixture.CreateAnonymous<MyClass>(); mc.MyText = "Ploeh";
By default, AutoFixture assigns anonymous values to all writable properties, but since they are writable, you can always explicitly give them different values if you care.
However, there are situations when a property is writable, but can't take just any value of its type. Sometimes this is a sign that you should reconsider your API, as I've previously described, but it may also be a legitimate situation.
Consider a Filter class that has Min and Max properties. To be semantically correct, the Min property must be less than or equal to the Max property. Each property is implemented like this:
public int Min { get { return this.min; } set { if (value > this.Max) { throw new ArgumentOutOfRangeException("value"); } this.min = value; } }
When you ask AutoFixture to create an instance of the Filter class, it will throw an exception because it's attempting to set the Min property after the Max property, and the default algorithm for numbers is to return numbers in an increasing sequence. (In this example, the Min property is being assigned a value after the Max property, but AutoFixture has no contract that states that the order in which properties are assigned is guaranteed.) In other words, this throws an exception:
var f = fixture.CreateAnonymous<Filter>();
To solve this problem, we will have to customize the assignment of the Min and Max properties, before we ask AutoFixture to create an instance of the Filter class. Here's how to do that:
int min = fixture.CreateAnonymous<int>(); int max = min + 1; var f = fixture.Build<Filter>() .With(s => s.Max, max) .With(s => s.Min, min) .CreateAnonymous();
The With method lets you specify an expression that identifies a property, as well as the value that should be assigned to that property. When you do that, AutoFixture will never attempt to assign an anonymous value to that property, but will instead use the value you specified.
In most cases, just creating a truly anonymous instance and subsequently explicitly assigning any significant values is easier, but using the Build method with one or more calls to the With method gives you the power to override any property assignments before the instance is created.
