How can I customize an entity further after applying EntityCustomization?

[bardock]

Hi Alex,

I've just faced a problem that I'd like to share with you.

I have a DefaultCustomization composed by your EntityCustomization and other customizations that are used in all my tests. Then at each test I add more customizations, applying them after the default customizations thus I could override them.

If I use fixture.Customize<Entity>(b => b.With(...)), it inserts a specimen builder at the top of fixture.Customizations, thus it overrides the EntityCustomization that I already applied with my default customizations.

How are you handling these kind of scenarios where you want some of your default customizations be applied before and some after the test's specific customizations?

I was thinking that maybe we could use an AutoFixture's Behaviour in order to avoid that the EntityCustomization logic be overridden by customizations.

Thank you very much!

[alexfoxgill]

In my own projects I've left it to AutoFixture to set the properties. However, sometimes I need to (for example) specify that a particular property should have a maximum length. I created a generic SpecimenBuilder class for this purpose:

fixture.Customizations
    .Add(new StringPropertyTruncateSpecimenBuilder<Person>(p => p.TelephoneHome, 20));

    public class StringPropertyTruncateSpecimenBuilder<TEntity> : ISpecimenBuilder
    {
        private readonly int _length;
        private readonly PropertyInfo _prop;

        public StringPropertyTruncateSpecimenBuilder(Expression<Func<TEntity, string>> getter, int length)
        {
            _length = length;
            _prop = (PropertyInfo)((MemberExpression)getter.Body).Member;
        }

        public object Create(object request, ISpecimenContext context)
        {
            var pi = request as PropertyInfo;

            return pi != null && AreEquivalent(pi, _prop)
                ? context.Create<string>().Substring(0, _length)
                : (object) new NoSpecimen(request);
        }

        private bool AreEquivalent(PropertyInfo a, PropertyInfo b)
        {
            return a.DeclaringType == b.DeclaringType
                   && a.Name == b.Name;
        }
    }

Is this the kind of thing you were looking for?

[bardock]

Well, I'm also leaving it to AutoFixture to set the properties, but if I want to specify a value for a property, I'm doing something like this:

fixture.Customize<Person>(c => c.With(p => p.IsActive, true));

I forked your repo and added some tests in order to reproduce and clarify the problem.

In the last commit I implemented a temporary solution (or workaround). If that's OK, I could refactor it.

Let me know what do you think about the problem and that solution.

Thanks!

[rsevil]

+1

[alexfoxgill]

Sorry for the slow response, I've been away but will look into this!

[alexfoxgill]

Let's look at the source of Fixture.Customize:

public void Customize<T>(Func<ICustomizationComposer<T>, ISpecimenBuilder> composerTransformation)
{
    if (composerTransformation == null)
    {
        throw new ArgumentNullException("composerTransformation");
    }

    var c = composerTransformation(SpecimenBuilderNodeFactory.CreateComposer<T>().WithAutoProperties(this.EnableAutoProperties));
    this.customizer.Insert(0, c);
}

So the intention of this method is to insert a new Customization which details exactly how the entity should be constructed. To me it seems like your solution using FromFactory would be the best way to go if you want to use the Fixture.Customize method. I tried to create a more generic version using this extension:

public static class FixtureExtensions
{
    public static void CustomizeWithoutOverride<T>(this Fixture fixture,
        Func<IPostprocessComposer<T>, ISpecimenBuilder> composerTransformation)
    {
        fixture.Customize<T>(x => composerTransformation(x.FromFactory(fixture.Engine)));
    }
}

However, this (predictably) causes a stack overflow!

My preferred approach would be to create a custom SpecimenBuilder which explicitly delegates object creation to the context, then sets the property. Something like the following:

public class PropertySettingSpecimenBuilder<T>: ISpecimenBuilder where T : class
{
    private readonly Action<T> _action;

    public PropertySettingSpecimenBuilder(Action<T> action)
    {
        _action = action;
    }

    public object Create(object request, ISpecimenContext context)
    {
        var specimen = context.Resolve(request);

        var ns = specimen as NoSpecimen;
        if (ns != null)
            return ns;

        var asT = specimen as T;
        if (asT == null)
            return specimen;

        _action(asT);
        return asT;
    }
}

You could then add this as a customization to the start of the list and would not need to use Customize

Does this help?