Nikos Baxevanis - AutoFixture

Categorized list of AutoFixture questions on Stack Overflow

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 09 Jun 2013 00:00:00 GTB Daylight Time

The complete list can be found here.

AutoFixture.Auto[Moq/RhinoMocks/FakeItEasy/NSubstitute]

AutoFixture.Idioms

AutoFixture.Xunit

Customizations

Freeze, Inject

Likeness, Likeness as Resemblance

Refactoring

Truly Constrained Non-Deterministic Numbers in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 08 Oct 2012 00:00:00 GTB Daylight Time

Numbers in AutoFixture are currently created using a strictly monotonically increasing sequence.

var fixture = new Fixture();

var i = fixture.CreateAnonymous<int>();
// Prints -> 1
var l = fixture.CreateAnonymous<long>();
// Prints -> 2
var f = fixture.CreateAnonymous<float>();
// Prints -> 3.0

Starting with version 2.13.0, by applying a specific customization numbers can also be created using a constrained non-deterministic sequence. The new customization is called RandomNumericSequenceCustomization.

var fixture = new Fixture()
    .Customize(new RandomNumericSequenceCustomization());

var i = fixture.CreateAnonymous<int>();
// Prints -> 122
var l = fixture.CreateAnonymous<long>();
// Prints -> 38
var f = fixture.CreateAnonymous<float>();
// Prints -> 147.0

Once the customization has been applied to a Fixture instance subsequent requests for numeric types will yield random non-repeatable numbers in the range of [1, 255]. When requesting more than 255 numbers the range is automatically changed to [256, 32767] and so on.

The default ranges are [1, 255], [256, 32767], and [32768, 2147483647].

Supplying a custom range

To supply a custom range, customize an instance of the Fixture class with an instance of the RandomNumericSequenceGenerator and pass to its constructor a sequence of integer numbers (e.g. -100, 100, 255).

The sequence must be two positive or negative numbers optionally followed by a series of greater numbers.

var fixture = new Fixture();
fixture.Customizations.Add(
    new RandomNumericSequenceGenerator(-100, 100, 255));

var i = fixture.CreateAnonymous<int>();
// Prints -> -95
var l = fixture.CreateAnonymous<long>();
// Prints -> 47
var f = fixture.CreateAnonymous<float>();
// Prints -> -82.0

After applying the customization, numbers are now created in the range of [-100, 100]. However, when requesting more numbers than the range size the range is automatically changed to [101, 255].

AutoFixture, xUnit.net, and Auto Mocking

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 31 Jul 2012 00:00:00 GTB Daylight Time

Update: In AutoFixture 3 numbers are random.

The features discussed in this post are available when using AutoFixture decleratively with the xUnit.net extension. In addition, it is required to have at least one of the extensions for Auto Mocking using AutoMoq, AutoRhinoMocks, AutoFakeItEasy, or AutoNSubstitute.

To install AutoFixture with xUnit.net data theories, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.Xunit

In the test method below we would like to use xUnit.net data theories to provide:

Auto-generated data specimens for d, s, i, a.
Auto-generated data specimens for _, s, i, a, and inline values for d.
Auto-generated data specimens for _, _, i, a, and inline values for d, s.

public void TestMethod(
    double d, string s, IInterface i, AbstractType a)
{
    Assert.True(
        d != 0    &&
        s != null &&
        i != null &&
        a != null
        );
}

That fact that argument i is an interface and argument a is an abstract class prevents us from using [InlineData], [AutoData], or [InlineAutoData] attributes.

AutoFixture allows us to easily define custom DataAttribute derived types:

By deriving from AutoDataAttribute and passing to the base constructor a customization that enables auto mocking with Moq, Rhino Mocks, FakeItEasy, or NSubstitute.
By deriving from CompositeDataAttribute and passing to the base constructor an array of DataAttribute derived type instances, e.g. an instance of InlineDataAttribute and an instance of AutoDataAttribute derived type.

Auto Mocking using Moq

To install AutoFixture with Auto Mocking using Moq, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoMoq

We decorate the test method with AutoMoqData and InlineAutoMoqData attributes:

[Theory]
[AutoMoqData]
[InlineAutoMoqData(2)]
[InlineAutoMoqData(3, "foo")]
public void WithMoq(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Output:

AutoMoqData:
  d = 1
  s = s05080d05-b874-4182-bba5-18678ad9b134
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy
  
InlineAutoMoqData:
  d = 2
  s = sce87888d-8cc8-4f69-927c-c4b1347d3147
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy

InlineAutoMoqData:
  d = 3
  s = foo
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy

Source code:

internal class AutoMoqDataAttribute : AutoDataAttribute
{
    internal AutoMoqDataAttribute()
        : base(new Fixture().Customize(new AutoMoqCustomization()))
    {
    }
}

internal class InlineAutoMoqDataAttribute : CompositeDataAttribute
{
    internal InlineAutoMoqDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoMoqDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using Moq can be found at AutoFixture as an auto-mocking container blog post.

Auto Mocking using Rhino Mocks

To install AutoFixture with Auto Mocking using Rhino Mocks, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoRhinoMocks

We decorate the test method with AutoRhinoMockData and InlineAutoRhinoMockData attributes:

[Theory]
[AutoRhinoMockData]
[InlineAutoRhinoMockData(2)]
[InlineAutoRhinoMockData(3, "foo")]
public void WithRhinoMocks(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Ouput:

AutoRhinoMockData:
  d = 1
  s = s01172643-5162-474f-bcfa-319ef40a8272
  i = Castle.Proxies.IInterfaceProxy201f58a5559841bfb41895881489658c
  a = Castle.Proxies.AbstractTypeProxy5a86172bbda14cc098b4c675c5b7e555

InlineAutoRhinoMockData:
  d = 2
  s = sd3b9c112-5181-4daa-9b2f-333c7498044a
  i = Castle.Proxies.IInterfaceProxy201f58a5559841bfb41895881489658c
  a = Castle.Proxies.AbstractTypeProxy5a86172bbda14cc098b4c675c5b7e555
  
InlineAutoRhinoMockData:
  d = 3
  s = foo
  i = Castle.Proxies.IInterfaceProxy201f58a5559841bfb41895881489658c
  a = Castle.Proxies.AbstractTypeProxy5a86172bbda14cc098b4c675c5b7e555

Source code:

internal class AutoRhinoMockDataAttribute : AutoDataAttribute
{
    internal AutoRhinoMockDataAttribute()
        : base(new Fixture().Customize(new AutoRhinoMockCustomization()))
    {
    }
}

internal class InlineAutoRhinoMockDataAttribute : CompositeDataAttribute
{
    internal InlineAutoRhinoMockDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoRhinoMockDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using Rhino Mocks can be found at Rhino Mocks-based auto-mocking with AutoFixture blog post.

Auto Mocking using FakeItEasy

To install AutoFixture with Auto Mocking using FakeItEasy, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoFakeItEasy

We decorate the test method with AutoFakeItEasyData or InlineAutoFakeItEasyData attributes:

[Theory]
[AutoFakeItEasyData]
[InlineAutoFakeItEasyData(2)]
[InlineAutoFakeItEasyData(3, "foo")]
public void WithFakeItEasy(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Output:

AutoFakeItEasyData:
  d = 1
  s = s2b4c118b-d18b-4782-992a-d4138c65fd2a
  i = Faked IInterface
  a = Faked AbstractType

InlineAutoFakeItEasyData:
  d = 2
  s = se8da7e09-ea4f-4d16-86bd-4229802e5f5d
  i = Faked IInterface
  a = Faked AbstractType

InlineAutoFakeItEasyData:
  d = 3
  s = foo
  i = Faked IInterface
  a = Faked AbstractType

Source code:

internal class AutoFakeItEasyDataAttribute : AutoDataAttribute
{
    internal AutoFakeItEasyDataAttribute()
        : base(new Fixture().Customize(new AutoFakeItEasyCustomization()))
    {
    }
}

internal class InlineAutoFakeItEasyDataAttribute : CompositeDataAttribute
{
    internal InlineAutoFakeItEasyDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoFakeItEasyDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using FakeItEasy can be found at Auto-Mocking with FakeItEasy and AutoFixture blog post.

Auto Mocking using NSubstitute

To install AutoFixture with Auto Mocking using NSubstitute, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoNSubstitute

We decorate the test method with AutoNSubstituteData or InlineAutoNSubstituteData attributes:

[Theory]
[AutoNSubstituteData]
[InlineAutoNSubstituteData(2)]
[InlineAutoNSubstituteData(3, "foo")]
public void WithNSubstitute(
    double d, string s, IInterface i, AbstractType a)
{
    Write(d, s, i, a);
}

Output:

AutoNSubstituteData:
  d = 1
  s = sf7ce77e0-c2b3-4749-b9ec-78f3aba0254a
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy
  
InlineAutoNSubstituteData:
  d = 2
  s = sf7ba31be-3136-4b50-a51f-3763f1d06004
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy

InlineAutoNSubstituteData:
  d = 3
  s = foo
  i = Castle.Proxies.IInterfaceProxy
  a = Castle.Proxies.AbstractTypeProxy

Source code:

internal class AutoNSubstituteDataAttribute : AutoDataAttribute
{
    internal AutoNSubstituteDataAttribute()
        : base(new Fixture().Customize(new AutoNSubstituteCustomization()))
    {
    }
}

internal class InlineAutoNSubstituteDataAttribute : CompositeDataAttribute
{
    internal InlineAutoNSubstituteDataAttribute(params object[] values)
        : base(new DataAttribute[] { 
            new InlineDataAttribute(values), new AutoNSubstituteDataAttribute() })
    {
    }
}

More information on AutoFixture with Auto Mocking using NSubstitute can be found at NSubstitute Auto-mocking with AutoFixture blog post.

URI support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 19 Apr 2012 00:00:00 GTB Daylight Time

Starting with version 2.10.0, AutoFixture supports the creation of Uniform Resource Identifiers and the Uri type.

It is now possible to create an anonymous variable for Uri as with any other common type:

var fixture = new Fixture();
var uri = fixture.CreateAnonymous<Uri>();
// Prints -> scheme://257eb39a-8305-4d13-a7cb-0c481b78809a/

By default, both the scheme name and the authority part are obtained from the context. A custom UriScheme class represents the URI scheme name while the authority part is an anonymous variable of type string.

Example URIs along with their component parts can be found here. Since both parts are received from the context, they can be easily customized.

Supplying a custom scheme name

The UriScheme type provides by default the name "scheme". However, by injecting a specific instance of this type we can easily override it with something else (e.g. "http").

var fixture = new Fixture();
fixture.Inject(new UriScheme("http"));
var uri = fixture.CreateAnonymous<Uri>(); 
// Prints -> http://abc9f406-16f2-4e06-b6f9-0750dc115ac3/

Supplying a custom authority

This is preferred only when each test constructs its own instance of the Fixture type since this change will apply for all the strings received from the context.

Since the authority part is a string received from the context, it is possible to modify the base of all strings and get the desired name for the authority.

var fixture = new Fixture();
fixture.Customizations.Add(
    new StringGenerator(() => "autofixture.codeplex.com"));
var uri = fixture.CreateAnonymous<Uri>(); 
// Prints -> scheme://autofixture.codeplex.com/

Supplying a custom Uri

As with any other generated specimen, it is possible to completely take over it's creation. Using a custom ISpecimenBuilder type, each time a Uri is requested, a predefined Uri will be returned.

public class CustomUriBuilder : ISpecimenBuilder
{
    public object Create(object request, ISpecimenContext context)
    {
        if (request == typeof(Uri))
        {
            return new Uri("http://autofixture.codeplex.com");
        }

        return new NoSpecimen(request);
    }
}

var fixture = new Fixture();
fixture.Customizations.Add(new CustomUriBuilder());
var uri = fixture.CreateAnonymous<Uri>(); 
// Prints -> http://autofixture.codeplex.com/

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

Dynamic Proxy overriding Equals in AutoFixture Likeness

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Mon, 20 Feb 2012 00:00:00 GTB Standard Time

From version 2.9.0 of AutoFixture, the Likeness class contains a new feature for creating a dynamic proxy that overrides Equals on the destination type.

As an example, we want to compare instances of the following types:

public class DoubleParameterType<T1, T2>
{
    public DoubleParameterType(T1 parameter1, T2 parameter2)
    {
        this.Parameter1 = parameter1;
        this.Parameter2 = parameter2;
    }

    public T1 Parameter1 { get; private set; }
    public T2 Parameter2 { get; private set; }
}

public class SingleParameterType<T>
{
    public SingleParameterType(T parameter)
    {
        this.Parameter = parameter;
    }

    public T Parameter { get; private set; }
}

We can have the following syntax (prior to version 2.9.0):

[Fact]
public void TestWithLikeness()
{
    // Fixture setup
    var value = new DoubleParameterType<int, double>(1, 2.0);

    Likeness<DoubleParameterType<int, double>, SingleParameterType<int>> sut 
        = value.AsSource()
               .OfLikeness<SingleParameterType<int>>();
            
    // Exercise system
    var result = sut.Equals(value);
    // Verify outcome
    Assert.True(result);
}

However, from version 2.9.0 there is also a new CreateProxy method on Likeness which returns a proxy of the destination type overriding Equals with Likeness's instance of IEqualityComparer (the SemanticComparer class):

[Fact]
public void TestWithLikenessProxy()
{
    // Fixture setup
    var value = new DoubleParameterType<int, double>(1, 2.0);
            
    SingleParameterType<int> sut
        = value.AsSource()
               .OfLikeness<SingleParameterType<int>>()
               .CreateProxy();
            
    // Exercise system
    var result = sut.Equals(value);
    // Verify outcome
    Assert.True(result);
}

Below is also an example, where we need to verify that an expectation was met:

public class Bar
{
    public string Zip { get; set; }
}

public class Foo
{
    public Bar Bar { get; private set; }

    public void DoSomething(ISomeContext ctx)
    {
        this.Bar = new Bar { Zip = "12345" };
        ctx.DoSomething(this.Bar);
    }
}

public interface ISomeContext
{
    void DoSomething(object request);
}

[Fact]
public void Test()
{
    var foo = new Foo();
    var ctx = new Mock<ISomeContext>();
    foo.DoSomething(ctx.Object);

    var bar = new Bar().AsSource().OfLikeness<Bar>().CreateProxy();
    bar.Zip = "12345";

    ctx.Verify(x => x.DoSomething(bar));
}

Although the new Bar instance is created inside the DoSomething method, we can pass a proxied Bar instance on the mock's Verify method.

Internally, a custom Proxy Generator was written which also supports types with non-parameterless constructors. In order to create proxies of such types, the values from the source have to be compatible with the parameters on the destination constructor. (The mapping between the two is made possible by using the same semantic heuristics, as the default semantic comparison.)

Auto-Mocking with FakeItEasy and AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Wed, 14 Dec 2011 00:00:00 GTB Standard Time

AutoFixture can become an auto-mocking container using Moq (described here) and Rhino Mocks (described here).

In addition to the above auto-mocking features it is now possible to use FakeItEasy.

To install AutoFixture with Auto Mocking using FakeItEasy, run the following command in the Package Manager Console:

PM> Install-Package AutoFixture.AutoFakeItEasy

To use it, add an AutoFakeItEasyCustomization to the Fixture instance:

var fixture = new Fixture()
    .Customize(new AutoFakeItEasyCustomization());

Here is a typical usage inside a test method which will automatically create mocked instances using FakeItEasy:

var fixture = new Fixture()
    .Customize(new AutoFakeItEasyCustomization());
var result = fixture.CreateAnonymous<IInterface>();

To explicitly use FakeItEasy inside a test you need to Freeze it first:

[Fact]
public void FixtureCanFreezeFake()
{
    // Fixture setup
    var fixture = new Fixture()
        .Customize(new AutoFakeItEasyCustomization());
    var dummy = new object();
    var fake = fixture.Freeze<Fake<IInterface>>();
    fake.CallsTo(x => x.MakeIt(dummy))
        .Returns(null);
    // Exercise system
    var result = fixture.CreateAnonymous<IInterface>();
    result.MakeIt(dummy);
    // Verify outcome
    A.CallTo(() => result.MakeIt(dummy)).MustHaveHappened();
    // Teardown
}

The above example can be made even more elegant by using AutoData theories:

[Theory, AutoFakeData]
public void FixtureCanFreezeFake([Frozen]Fake<IInterface> fake, IInterface sut)
{
    var dummy = new object();
    sut.MakeIt(dummy);
    A.CallTo(() => sut.MakeIt(dummy)).MustHaveHappened();
}

Below is the code for the AutoFakeDataAttribute class:

public class AutoFakeDataAttribute : AutoDataAttribute
{
    public AutoFakeDataAttribute()
        : base(new Fixture().Customize(new AutoFakeItEasyCustomization()))
    {
    }
}

An automatically published release created from the latest successful build can also be downloaded from here.

RegularExpressionAttribute support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 11 Dec 2011 00:00:00 GTB Standard Time

Continuing the support of DataAnnotations as described here and here, there is now added support for the RegularExpressionAttribute class.

Starting with version 2.6.0, when this attribute is applied on a data field AutoFixture will try to generate a value that matches the specified regular expression.

Let's take as an example the following type:

public class RegularExpressionValidatedType
{
    // Allow up to 40 uppercase and lowercase.
    [RegularExpression("^[a-zA-Z''-'\s]{1,40}$")]
    public string Name { get; set; }
    
    [RegularExpression("^http\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?$")]
    public string Url { get; set; }
}

Prior to version 2.6.0 if we request an anonymous instance from AutoFixture, by default we would get back an instance of the above type with it's properties containing values similar to those below.

However, from version 2.6.0 AutoFixture can handle requests with regular expressions, through the RegularExpressionAttribute class, by issuing a new request for the specified regular expression pattern.

The idea behind this new feature is that members of a Regular Expression (Regex) can be generated by first transforming the Regex into a Finite-state machine, particularly a Deterministic finite automaton.

You may also watch a short, introductory, video on the subject here. (Although it is for Rex, I find it very descriptive.)

The current implementation uses internally the algorithms provided by the dk.brics.automaton and Xeger packages.

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

StringLengthAttribute support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 18 Sep 2011 00:00:00 GTB Daylight Time

Continuing the support of DataAnnotations as described here, there is now added support for the StringLengthAttribute class. Starting with version 2.4.0, when this attribute is applied on a data field it can specify the maximum length of characters that are allowed.

Let's take as an example the following type:

public class StringLengthValidatedType
{
    [StringLength(3)]
    public string Property { get; set; }
}

Prior to version 2.4.0 if we request an anonymous instance from AutoFixture, by default we would get back an instance of the above type with it's Property containing a value similar to the one below.

However, after version 2.4.0 AutoFixture can handle requests with string length constraints through the StringLengthAttribute class by issuing a new request for a constrained string.

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

RangeAttribute support in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Tue, 13 Sep 2011 00:00:00 GTB Daylight Time

Support for types from the System.ComponentModel.DataAnnotations namespace is one of the most voted features for AutoFixture. Starting with version 2.3.1 AutoFixture supports the RangeAttribute class. When this attribute is applied on a data field it can specify the numeric range constraints for it's value.

Let's take as an example the following type:

public class RangeValidatedType
{
    [Range(10, 20)]
    public int Property { get; set; }
}

Prior to version 2.3.1 if we request an anonymous instance from AutoFixture (or better, a specimen from AutoFixture's kernel) we would get back an instance of the above type with it's Property containing a value probably out of the specified numeric range.

However, after version 2.3.1 AutoFixture can handle requests with numeric range constraints through the RangeAttribute class by issuing a new request for a value inside the specified range.

An automatically published release created from the latest successful build can be downloaded from here. The latest version is also live on NuGet.

Heuristics for Static Factory Methods in AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 25 Aug 2011 00:00:00 GTB Daylight Time

Here is a type with a private constructor:

public class TypeWithFactoryMethod
{
    private TypeWithFactoryMethod() 
    {
    }

    public static TypeWithFactoryMethod Create()
    {
        return new TypeWithFactoryMethod();
    }

    public static TypeWithFactoryMethod Create(object argument)
    {
        return new TypeWithFactoryMethod();
    }
}

In order to create an instance of that type we have to call one of it's static factory methods, for example:

var instance = TypeWithFactoryMethod.Create();

If we try to create an Anonymous Variable with AutoFixture right now (version 2.1) it will throw an exception since there are no public constructors:

var fixture = new Fixture();
var result = fixture.CreateAnonymous<TypeWithFactoryMethod>();

Using the latest version from trunk (and on the next public release) the above code will work. It will successfully return an instance of the type by using a set of heuristics that enable AutoFixture to search for static factory methods.

The latest build (including strong names) can be downloaded from here.

Combining Data Theories in AutoFixture.Xunit extension

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Thu, 25 Aug 2011 00:00:00 GTB Daylight Time

xUnit.net supports parameterized tests via data theories which are types deriving from the Xunit.Extensions.DataAttribute type. Some popular attributes include:

InlineDataAttribute, PropertyDataAttribute and ClassDataAttribute.

AutoFixture.Xunit extension includes a very useful type, for providing auto-data theories, called AutoMoqDataAttribute.

Imagine a Scenario where we have a unit test method with 3 parameters. We want the first parameters to be supplied by InlineData and the rest by AutoFixture using AutoMoqData.

[Theory]
[InlineAutoData("foo")]
[InlineAutoData("foo", "bar")]
public void Test(string s1, string s2, MyClass myClass)
{
}

This is now possible using the InlineAutoDataAttribute type which is now on the trunk and will be available on next public release (after version 2.1). It provides a data source for a data theory, with the data coming from inline values combined with auto-generated data specimens generated by AutoFixture.

InlineAutoDataAttribute derives from CompositeDataAttribute, an implementation of DataAttribute that composes other DataAttribute instances.

Here is how it works:

Delegate the GetData method call to the first attribute.
Loop through the results from the first attribute and check if the length of each object array matches the number of arguments required by the method.
- If so, yield the object array.
- If not, invoke GetData on the next attribute.
  - Throw away the first objects from the result in order to continue from where it ran out of objects from the first result set and concatenate the rest to the previous array.

Recursively repeat this process until all object arrays have the required length.

While this feature comes with AutoFixture.Xunit extension, the CompositeDataAttribute class depends only on the xunit.extensions assembly.

You may compile the code from the latest trunk version, alternatively the latest build (including strong names) can be downloaded from here.

Persistence specification testing combined with AutoFixture

nikos.baxevanis@gmail.com (Nikos Baxevanis) — Sun, 13 Mar 2011 00:00:00 GTB Standard Time

When working with NHibernate you need to make sure that your mappings are correct. At least, you have to make sure that when you save an item you can also qet that item back.

If you are using FluentNHibernate you can use the PersistenceSpecification<T> class. However, the PersistenceSpecification<T> class requires that you pass the property to check and also a value for that property.

By using AutoFixture you can easily create objects that you can pass inside the CheckXx methods:

[Fact]
public void ShouldVerifyTheMappings()
{
    var fixture = new Fixture();

    using (session)
    {
        new PersistenceSpecification<EventType>(session)
            .CheckProperty(x => x.EventTypeId, 
                fixture.CreateAnonymous<long>())
            .CheckProperty(x => x.EventTypeName, 
                fixture.CreateAnonymous<string>())
            .CheckProperty(x => x.ExchangeServerId, 
                fixture.CreateAnonymous<int>())
            .CheckProperty(x => x.LastUpdatedOn, 
                DateTime.Today)
            .CheckProperty(x => x.NextMarketId, 
                fixture.CreateAnonymous<long>())
            .CheckReference(x => x.Bookmaker, 
                fixture.CreateAnonymous<Bookmaker>())
            .VerifyTheMappings();
    }
}

Combining AutoFixture with the PersistenceSpecification<T> class results in writing less code when testing NHibernate mappings, specially when dealing with complex types.