Passing collection fixture to a class fixture

[rc14193]

Is it possible to pass a collection fixture to a class fixture? I have some tests where I have some data initialization where order matters and there is shared setup across the whole collection and then specific configuration for different tests. This made me think it might be useful to have a collection fixture that can then be passed to the different class fixtures. I can't find anything on this in the documentation.

Is there maybe a better design choice then this? Is this possible?

[rc14193]

https://xunit.net/docs/shared-context

Note that you cannot control the order that fixture objects are created, and fixtures cannot take dependencies on other fixtures. If you have need to control creation order and/or have dependencies between fixtures, you should create a class which encapsulates the other two fixtures, so that it can do the object creation itself.

I'm guessing this answers my question but I wasn't certain since the creation order for class vs collection fixtures is fundamentally different.

[DalekBaldwin]

This blog post seems to claim that this was quite possible at some point: https://www.jimmybogard.com/integration-testing-with-xunit/ (section: "Class Fixture Design"):

public class MyTestClass_For_Some_Context
    : IClassFixture<MyTestClass_For_Some_Context.Fixture> {
    private readonly Fixture _fixture;
    public MyTestClass_For_Some_Context(Fixture fixture)
        => _fixture = fixture;
    
    [Collection(nameof(SharedFixture)]
    public class Fixture : IAsyncLifetime {
        private readonly SharedFixture _sharedFixture;
        public Fixture(SharedFixture sharedFixture)
            => _sharedFixture = sharedFixture;

        public async Task InitializeAsync() {
            // Arrange, Act
        }
        public Order Order { get; set; }
        public OtherContext Context { get; set; }
        // no need for DisposeAsync
    }

    [Fact]
    public void Should_have_one_behavior() {
       // Assert
    }

    [Fact]
    public void Should_have_other_behavior() {
       // Assert
    }
}

However, I can't seem to get this pattern to work even in older versions -- it always yields an error of the form:

   System.AggregateException : One or more errors occurred. (Class fixture type 'FixtureTest.Fixture' had one or more unresolved constructor arguments: SharedFixture sharedFixture) (The following constructor parameters did not have matching fixture data: Fixture fixture)
---- Class fixture type 'FixtureTest.Fixture' had one or more unresolved constructor arguments: SharedFixture sharedFixture
---- The following constructor parameters did not have matching fixture data: Fixture fixture

[bradwilson]

@DalekBaldwin Your example code here seems wrong (and is missing important code; namely, the definition of SharedFixture).

The class Fixture is incorrectly decorated with [Collection]. That's intended to be decorated onto your test class to indicate which collection the tests in that class are in.

In addition, you need a collection definition class to indicate which collection fixture(s) are available to tests in the collection.

I recommend you look at my example below for the correct structuring of the classes involved. Fixture1 is the fixture that's applied at the collection level, and Fixture2 is the fixture that's applied at the class level, that accepts the instance of Fixture1 via constructor argument. The mappings to your sample, I think, would be Fixture1 => SharedFixture, Fixture2 => Fixture.

[bradwilson]

Yes, this does work as you'd expect:

using Xunit;

public class Fixture1
{
    public static int CtorCount = 0;

    public Fixture1() => CtorCount++;
}

public class Fixture2
{
    public Fixture1 F1;

    public Fixture2(Fixture1 f1) => F1 = f1;
}

[CollectionDefinition(nameof(MyCollection))]
public class MyCollection : ICollectionFixture<Fixture1>
{ }

[Collection(nameof(MyCollection))]
public class UnitTest1 : IClassFixture<Fixture2>
{
    Fixture2 f2;

    public UnitTest1(Fixture2 f2) => this.f2 = f2;

    [Fact]
    public void Test1()
    {
        Assert.NotNull(f2.F1);
        Assert.Equal(1, Fixture1.CtorCount);
    }
}

[Collection(nameof(MyCollection))]
public class UnitTest2 : IClassFixture<Fixture2>
{
    Fixture2 f2;

    public UnitTest2(Fixture2 f2) => this.f2 = f2;

    [Fact]
    public void Test2()
    {
        Assert.NotNull(f2.F1);
        Assert.Equal(1, Fixture1.CtorCount);
    }
}

Note that the discussion about "creation order" is when class fixtures depend on class fixtures (or collection fixtures depend on collection fixtures). Since collection fixtures and class fixtures are created at different times by definition, you can always be sure that collection fixtures are created before class fixtures.

[maranmaran]

I find this working only if both fixtures are part of the same assembly.

[bradwilson]

I can't repro. I put the fixtures in one assembly, put the test in another, and everything worked.
xunit2699.zip