0

我是单元测试的新手，下面是使用 xunit 进行单元测试的代码

public class FloorManager
{
    public List<FloorInfo> Floors { get; }

    public FloorManager()
    {
        Floors = new List<FloorInfo>();
        SelectedFloor = -1;
    }        

    public FloorInfo FindFloorByName(string name)
    {
        FloorInfo fInfo = Floors.Find(floor => floor.Name == name);
        return fInfo;
    }
}

public class FloorInfo
{
    public String Name { get; set; }
}

我有一个测试：

[Fact]
public void FindFloorByName_ShouldGetName()
{
    using (var mock = AutoMock.GetLoose())
    {
        string floorName = "First Floor";
        var fInfo = new FloorInfo { Name = floorName };
        mock.Mock<FloorManager>()
            .Setup(x => x.FindFloorByName(floorName)).Returns(fInfo);

        var cls = mock.Create<FloorManager>();
        var expected = "First Floor";

        var actual = cls.FindFloorByName(floorName);

        Assert.True(expected == actual.Name);
    }
}

但是当我运行测试时，它给了我错误：-

> `System.NotSupportedException : Unsupported expression: x => x.FindFloorByName(FloorManagerTests.<>c__DisplayClass0_0.floorName)`

请给我解决方案如何测试上述功能以通过测试用例

4

1 回答 1

0

在原始问题中提供的所示代码示例中没有什么可以模拟的。

此外，在单独进行单元测试时，通常不会模拟被测主题 (SUT)

以下面的类为例

public class FloorManager {
    private List<FloorInfo> floors;

    public FloorManager() {
        floors = new List<FloorInfo>();
    }

    public IEnumerable<FloorInfo> Floors => floors;

    public FloorInfo FindFloorByName(string name) {
        FloorInfo fInfo = floors.Find(floor => floor.Name == name);
        return fInfo;
    }

    public  void Add(FloorInfo floor) {
        floors.Add(floor);
    }
}

public class FloorInfo {
    public String Name { get; set; }
}

对面向公众的学科类成员的一些简单测试

[TestClass]
public class FloorManagerTests {
    [TestMethod]
    public void Should_Create_Default_FloorManager() {
        //Arrange
        FloorManager subject = null;

        //Act
        subject = new FloorManager();

        //Assert - FluentAssertions
        subject.Should().NotBeNull();
        subject.Floors.Should()
            .NotBeNull()
            .And.HaveCount(0);
    }

    [TestMethod]
    public void Should_Add_Floor() {
        //Arrange
        string floorName = "First Floor";
        var floor = new FloorInfo { Name = floorName };
        var subject = new FloorManager();

        //Act
        subject.Add(floor);

        //Assert - FluentAssertions
        subject.Floors.Should().HaveCount(1);
    }

    [TestMethod]
    public void Should_FindFloorByName() {
        //Arrange
        string expected = "First Floor";
        var floor = new FloorInfo { Name = expected };
        var subject = new FloorManager();
        subject.Add(floor);

        //Act
        FloorInfo actual = subject.FindFloorByName(expected);

        //Assert - FluentAssertions
        actual.Should().NotBeNull();
        actual.Name.Should().Be(expected);
    }
}

随着主题类的复杂性增加，可以添加更多测试来验证预期行为。

如果经理改为依赖于服务

例如，

public class FloorManager {
    private IFloorCollection floors;

    public FloorManager(IFloorCollection floors) {
        this.floors = floors;
    }

    public IEnumerable<FloorInfo> Floors => floors.All;

    public FloorInfo FindFloorByName(string name) {
        FloorInfo fInfo = floors.Find(floor => floor.Name == name);
        return fInfo;
    }

    public void Add(FloorInfo floor) {
        floors.Add(floor);
    }
}

public interface IFloorCollection {
    IEnumerable<FloorInfo> All { get; }
    void Add(FloorInfo floor);
    FloorInfo Find(Func<FloorInfo, bool> p);

}

public class FloorInfo {
    public String Name { get; set; }
}

然后需要模拟依赖关系以便单独测试主题。

[TestMethod]
public void Should_FindFloorByName() {
    using (var mock = AutoMock.GetLoose()) {
        //Arrange
        string expected = "First Floor";
        var floor = new FloorInfo { Name = expected };
        FloorManager subject = mock.Create<FloorManager>();
        mock.Mock<IFloorCollection>()
            .Setup(_ => _.Find(It.Is<Func<FloorInfo, bool>>(f => f(floor))))
            .Returns(floor);

        //Act
        FloorInfo actual = subject.FindFloorByName(expected);

        //Assert - FluentAssertions
        actual.Should().NotBeNull();
        actual.Name.Should().Be(expected);
    }
}
于 2019-10-09T12:40:06.763 回答