Creating a fake with provided constructor arguments ordering should not matter

Here an idea:

When I create a fake it allows me to specify constructor arguments. My opinion is that when there are no constructor arguments of the same type the order of the constructor arguments should not matter in the provided object array. Here the repro:

public class OtherInfrastructureStuff
{
    private readonly JustAnotherTool tool;

    private readonly JsonTextWriter textwriter;

    public OtherInfrastructureStuff(JustAnotherTool tool, JsonTextWriter textwriter)
    {
        this.tool = tool;
        this.textwriter = textwriter;
    }
 }

This works:

[TestFixture]
public class SomeInfrastructureTest
{
    private OtherInfrastructureStuff other;

    private SomeInfrastructureStuff testee;

    [SetUp]
    public void SetUp()
    {
        this.other =
           A.Fake<OtherInfrastructureStuff>(
               options =>
               options.WithArgumentsForConstructor(
                   new object[] { A.Fake<JustAnotherTool>(), new JsonTextWriter(new StringWriter(new StringBuilder())) }));

        this.testee = new SomeInfrastructureStuff(this.other);
    }
 }

as soon as I swap out the parameters the setup fails:

[TestFixture]
public class SomeInfrastructureTest
{
    private OtherInfrastructureStuff other;

    private SomeInfrastructureStuff testee;

    [SetUp]
    public void SetUp()
    {
        this.other =
           A.Fake<OtherInfrastructureStuff>(
               options =>
               options.WithArgumentsForConstructor(
                   new object[] { new JsonTextWriter(new StringWriter(new StringBuilder())),  A.Fake<JustAnotherTool>() }));

        this.testee = new SomeInfrastructureStuff(this.other);
    }
 }

I see that you cannot provide this in case the constructor looks in example like this:

public class OtherInfrastructureStuff
{
    private readonly JustAnotherTool tool;

    private readonly JustAnotherTool anotherTool;

    public OtherInfrastructureStuff(JustAnotherTool tool, JustAnotherTool anotherTool)
    {
        this.tool = tool;
        this.anotherTool= anotherTool;
    }
 }

But with multiple different parameters the order should not matter. Thoughts?

Daniel

[adamralph]

Interesting. What about when the constructor is declared in terms of interfaces? E.g.

public Foo(IBar bar, IInheritsFromIBar baz)

A.Fake<Foo>(o => o.
    WithArgumentsForConstructor(new object[] { new Bar(), new InheritsFromBar());

I wonder how it easy it would be to come up with a good enough type resolution algorithm.

[adamralph]

@danielmarbach thanks for raising this. Given lack of enthusiasm to have this in the core package we decided to close this.