Question

我有以下类型层次结构：

public abstract class ResourceId
{
}

public class CarId : ResourceId
{
}

public class PlaneId: ResourceId
{
}

public interface IResource
{
  ResourceId Id { get; set; }
}

public class Plane : IResource
{
  public ResourceId Id { get; set; }
}

public class Car : IResource
{
  public ResourceId Id { get; set; }
}

我希望AutoFixture在尝试创建平面或汽车时创建“正确”类型的ResourceId。

我尝试使用：

_fixture.Customize<Plane>(composer => 
    composer.With(h => h.Id, _fixture.Create<PlaneId>()));

但是，当然会为每个实例创建相同的ID。我希望每个人都有一个唯一的ID。

最佳方法是什么？

Answer 1

这是一个简单的方法来做你想做的事：

[Fact]
public void HowToUseFixtureToCreatePlanesWithNewIds()
{
    var fixture = new Fixture();
    fixture.Customize<Plane>(c => c
        .Without(p => p.Id)
        .Do(p => p.Id = fixture.Create<PlaneId>()));

    var planes = fixture.CreateMany<Plane>();

    Assert.True(planes.Select(p => p.Id).Distinct().Count() > 1);
}

但是，如果我是你，我会认真考虑简化那个类层次......

Answer 2

有一种方法可以满足您的要求，但它需要鲜为人知的自定义API：Register方法。

Register的目的是允许用户为特定类型指定工厂功能。然后，AutoFixture会将该类型对象的创建委托给该函数。

Register的一个显着特点是它能够提供匿名对象，以便在需要时将其作为参数传递给工厂函数。它通过一些重载来实现。以下是a few examples：

Register<T>(Func<T> factory)未向工厂提供任何参数
Register<T1, T>(Func<T1, T> factory)提供一个T1类型的参数来创建T类型的对象
Register<T1, T2, T>(Func<T1, T2, T> factory)提供了T1和T2类型的两个参数来创建T类型的对象

现在，我们可以使用此功能自定义Car和Plane类型的对象的方式，方法是将CarId和PlanId的匿名实例分配给Id 1}}属性：

[Fact]
public void Test()
{
    var fixture = new Fixture();
    fixture.Register<CarId, Car>(id =>
    {
        var resource = new Car { Id = id };
        return resource;
    });
    fixture.Register<PlaneId, Plane>(id =>
    {
        var resource = new Plane { Id = id };
        return resource;
    });

    Assert.NotSame(fixture.Create<Car>().Id, fixture.Create<Car>().Id);
    Assert.NotSame(fixture.Create<Plane>().Id, fixture.Create<Plane>().Id);
}

此测试通过，因为传递给工厂函数的CarId和PlanId对象是由AutoFixture 创建的，因此每次都不同。

Answer 3

您必须为每个类自定义创建算法，在此示例中为Car和Plane，如以下传递测试所示：

[Fact]
public void Test()
{
    var fixture = new Fixture();
    fixture.Customize<Plane>(c => c
        .With(x => x.Id, fixture.Create<PlaneId>()));
    fixture.Customize<Car>(c => c
        .With(x => x.Id, fixture.Create<CarId>()));

    var plane = fixture.Create<Plane>();
    var car = fixture.Create<Car>();

    Assert.IsType<PlaneId>(plane.Id);
    Assert.IsType<CarId>(car.Id);
}

根据上下文为抽象属性创建具体类型

3 个答案: