A few months ago I described how you can use AutoFixture's With method to assign property values as part of building up an anonymous variable. In that scenario, the With method is used to explicitly assign a particular, pre-defined value to a property.
There's another overload of the With method that doesn't take an explicit value, but rather uses AutoFixture to create an anonymous value for the property. So what's the deal with that if AutoFixture's default behavior is to assign anonymous values to all writable properties?
In short it's an opt-in mechanism that only makes sense if you decide to opt out of the AutoProperties features.
As always, let's look at an example. This time, I've decided to show you a slightly more realistic example so that you can get an idea of how AutoFixture can be used to aid in unit testing. This also means that the example is going to be a little more complex than usual, but it's still simple.
Imagine that we wish to test that an ASP.NET MVC Controller Action returns the correct result. More specifically, we wish to test that the Profile method on MyController returns a ViewResult with the correct Model (the current user's name, to make things interesing).
Here's the entire test. It may look more complicated than it is – it's really only 10 lines of code, but I had to break them up to prevent unpleasant wrapping if your screen is narrow.
[TestMethod]
public void ProfileWillReturnResultWithCorrectUserName()
{ // Fixture setup
var fixture = new Fixture();
fixture.Customize<ControllerContext>(ob => ob
.OmitAutoProperties()
.With(cc => cc.HttpContext));
var expectedUserName =
fixture.CreateAnonymous("UserName");
var httpCtxStub = new Mock<HttpContextBase>();
httpCtxStub.SetupGet(x => x.User).Returns(
new GenericPrincipal(
new GenericIdentity(expectedUserName), null));
fixture.Register(httpCtxStub.Object);
var sut = fixture.Build<MyController>()
.OmitAutoProperties()
.With(c => c.ControllerContext)
.CreateAnonymous();
// Exercise system
ViewResult result = sut.Profile();
// Verify outcome
var actual = result.ViewData.Model;
Assert.AreEqual(expectedUserName, actual, "User");
// Teardown
}
Apart from AutoFixture, I'm also making use of Moq to stub out HttpContextBase.
You can see the Anonymous With method in two different places: in the call to Customize and when the SUT is being built. In both cases you can see that the call to With follows a call to OmitAutoProperties. In other words: we are telling AutoFixture that we don't want any of the writable properties to be assigned a value except the one we identify.
Let me highlight some parts of the test.
fixture.Customize<ControllerContext>(ob => ob
.OmitAutoProperties()
.With(cc => cc.HttpContext));
This line of code instructs AutoFixture to always create a ControllerContext in a particular way: I don't want to use AutoProperties here, because ControllerContext has a lot of writable properties of abstract types, and that would require me to set up a lot of Test Doubles if I had to assign values to all of those. It's much easier to simply opt out of this mechanism. However, I would like to have the HttpContext property assigned, but I don't care about the value in this statement, so the With method simply states that AutoFixture should assign a value according to whatever rule it has for creating instances of HttpContextBase.
I can now set up a Stub that populates the User property of HttpContextBase:
var httpCtxStub = new Mock<HttpContextBase>();
httpCtxStub.SetupGet(x => x.User).Returns(
new GenericPrincipal(
new GenericIdentity(expectedUserName), null));
fixture.Register(httpCtxStub.Object);
This is registered with the fixture instance which closes the loop to the previous customization.
I can now create an instance of my SUT. Once more, I don't want to have to set up a lot of irrelevant properties on MyController, so I opt out of AutoProperties and then explicitly opt in on the ControllerContext. This will cause AutoFixture to automatically populate the ControllerContext with the HttpContext Stub:
var sut = fixture.Build<MyController>()
.OmitAutoProperties()
.With(c => c.ControllerContext)
.CreateAnonymous();
For completeness' sake, here's the MyController class that I am testing:
public class MyController : Controller
{ public ViewResult Profile()
{ object userName = this.User.Identity.Name;
return this.View(userName);
}
}
This test may seem complex, but it really accomplishes a lot in only 10 lines of code, considering that ASP.NET MVC Controllers with a working HttpContext are not particularly trivial to set up.
In summary, this With method overload lets you opt in on one or more explicitly identified properties when you have otherwise decided to omit AutoProperties. As all the other Builder methods, this method can also be chained.