模拟只读索引器属性

本文关键字：属性 索引 只读 模拟 | 更新日期: 2023-09-27 18:04:00

我想知道如何模拟索引属性，这方面有很多问题:

  1. Moq一个索引属性，并在返回/回调中使用索引值
  2. 索引属性的最小起订量
  3. 如何设置索引属性

等。但在我的情况下，有一个额外的复杂性。索引属性是只读的。因此，我需要能够测试一段执行以下操作的代码

if (workbook.Worksheets.Cast<IWorksheet>().Any(
        ws => ws.Name.CompareNoCase(Keywords.Master)))
{
    ...
}

，其中有如下的类结构

public interface IWorkbook
{
    IWorksheets Worksheets { get; }
}
public interface IWorksheets : IEnumerable
{
    IWorksheet this[int index] { get; }
    IWorksheet this[string name] { get; }
    int Count { get; }
    IWorksheet Add();
    IWorksheet AddAfter(IWorksheet sheet);
    IWorksheet AddBefore(IWorksheet sheet);
    bool Contains(IWorksheet worksheet);
}
public interface IWorksheet
{
    string Name { get; set; }
}

所以在我的测试方法中，我尝试过(并且失败了)通过重写GetEnumerator()方法来做到这一点，因为这正是Cast()调用的;我这样做:

List<string> fakeSheetNames = new List<string>()
{
    "Master", "A", "B", "C", "__ParentA", "D", "wsgParentB", "E", "F","__ParentC", "__ParentD", "G" 
};
List<IWorksheet> worksheetMockList = new List<IWorksheet>();
foreach (string name in fakeSheetNames)
{
    Mock<IWorksheet> tmpMock = new Mock<IWorksheet>();
    tmpMock.Setup(p => p.Name).Returns(name);
    tmpMock.Setup(p => p.Visible)
        .Returns(parentPrefixes.Any(p => name.StartsWith(p)) ? 
            SheetVisibility.Hidden : 
            SheetVisibility.Visible);
    worksheetMockList.Add(tmpMock.Object);
}
Mock<IWorkbook> mockWorkbook = new Mock<IWorkbook>();
mockWorkbook
    .Setup(p => p.Worksheets.GetEnumerator())
    .Returns(worksheetMockList.GetEnumerator());
// I can't do this as per the threads referenced above, as the property is read only.
//for (int i = 0; i < worksheetMockList.Count; ++i)
    //mockWorkbook.SetupGet(p => p.Worksheets[i] = worksheetMockList[i])...

如何模拟我的workbook.Worksheets只读迭代器属性?

我还有一个抽象层次。我需要将IWorkbook添加到IWorkbooks集合中(就像我们对IWorksheets所做的那样)。我没有把这个放在原来的问题，因为它只是做同样的事情，因为我们做了IWorksheets，无论如何它不工作。接口为

public interface IWorkbookSet
{
    ...
    IWorkbooks Workbooks { get; }
}

和

public interface IWorkbooks : IEnumerable
{
    IWorkbook this[int index] { get; }
    IWorkbook this[string name] { get; }
    int Count { get; }
    ...
}

因此，为了尝试处理这个问题，我以以下方式嘲笑下面的伟大答案。然而，下面的循环并不像预期的那样工作。

List<string> fakeSheetNames = new List<string>()
{
    "Master",
    "A",
    "B",
    "C",
    "__ParentA", 
    "D",
    "wsgParentB", 
    "E",
    "F",
    "__ParentC",
    "__ParentD",
    "G"
};

Mock<IWorkbook> mockWorkbook = new Mock<IWorkbook>();
List<IWorksheet> worksheetMockList = new List<IWorksheet>();
foreach (string name in fakeSheetNames)
{
    Mock<IWorksheet> tmpWorksheetMock = new Mock<IWorksheet>();
    tmpWorksheetMock.Setup(p => p.Name).Returns(name);
    tmpWorksheetMock.Setup(p => p.Visible)
        .Returns(parentPrefixes.Any(p => name.StartsWith(p)) ? 
            SheetVisibility.Hidden : 
            SheetVisibility.Visible);
    worksheetMockList.Add(tmpWorksheetMock.Object);
}
var mockWorksheets = new Mock<IWorksheets>();
mockWorksheets.Setup(m => m[It.IsAny<int>()]).Returns<int>(index => worksheetMockList[index]);
mockWorksheets.Setup(m => m.GetEnumerator()).Returns(worksheetMockList.GetEnumerator());
mockWorkbook
    .Setup(p => p.Worksheets)
    .Returns(mockWorksheets.Object);
mockWorkbook.Setup(p => p.Name).Returns("Name");
mockWorkbook.Setup(p => p.FullName).Returns("FullName");
// This works.
foreach (IWorksheet ws in mockWorkbook.Object.Worksheets)
    Trace.WriteLine(ws.Name);
mockWorkbookSet = new Mock<IWorkbookSet>();
var mockWorkbooks = new Mock<IWorkbooks>();
List<IWorkbook> workbookMockList = new List<IWorkbook>() { mockWorkbook.Object };
mockWorkbooks.Setup(m => m[It.IsAny<int>()]).Returns<int>(index => workbookMockList[index]);
mockWorkbooks.Setup(m => m.GetEnumerator()).Returns(workbookMockList.GetEnumerator());
mockWorkbookSet
    .Setup(p => p.Workbooks)
    .Returns(mockWorkbooks.Object);
// Count is zero here??
foreach (IWorkbook wb in mockWorkbookSet.Object.Workbooks)
    Trace.WriteLine(wb.Worksheets.Count);

非常感谢。

编辑#2:使用你的代码，我有一些有趣的行为…

// Setup test.
var workbookSet = mockWorkbookSet.Object;
var actual = workbookSet
     .Workbooks[expectedWorkBooksIndex]
     .Worksheets[expectedWorkSheetIndex];
// This prints "A" - GOOD!
Trace.WriteLine("Actual " + actual.Name);
// This passes.
Assert.AreEqual(expected, actual);
// This works.
foreach (IWorksheet ws in mockWorkbook.Object.Worksheets)
    Trace.WriteLine(ws.Name);
// This works.
Trace.WriteLine(mockWorkbookSet.Object.Workbooks[0].Name);
// This does not write anything - WHY?
foreach (IWorksheet ws in mockWorkbookSet.Object.Workbooks[0].Worksheets.Cast<IWorksheet>())
    Trace.WriteLine(ws.Name);
// This fails.
foreach (IWorkbook workbook in workbookSet.Workbooks.Cast<IWorkbook>())
    Assert.IsTrue(workbook.Worksheets.Count > 0);

模拟只读索引器属性

使用 
mockWorkSheets
    .Setup(m => m[It.IsAny<int>()])
    .Returns<int>(index => worksheetMockList[index]);

，其中It.IsAny<int>()和.Returns<int>(index => ...)允许访问传递给模拟的值您可以通过.Returns方法访问索引。

下面的示例展示了如何设置模拟

[TestMethod]
public void Mock_Readonly_Indexer_Property() {
    //Arrange
    var parentPrefixes = new List<string>() { "__", "wsg" };
    var fakeSheetNames = new List<string>(){
        "Master",
        "A",
        "B",
        "C",
        "__ParentA", 
        "D",
        "wsgParentB", 
        "E",
        "F",
        "__ParentC",
        "__ParentD",
        "G"
    };
    //Worksheets
    var fakeWorkSheetsList = new List<IWorksheet>();
    foreach (string name in fakeSheetNames) {
        var tmpMock = Mock.Of<IWorksheet>();
        tmpMock.Name = name;
        tmpMock.Visible = parentPrefixes.Any(p => name.StartsWith(p)) ?
                SheetVisibility.Hidden :
                SheetVisibility.Visible;
        fakeWorkSheetsList.Add(tmpMock);
    }
    var mockWorkSheets = new Mock<IWorksheets>();
    mockWorkSheets.Setup(m => m[It.IsAny<int>()])
        .Returns<int>(index => fakeWorkSheetsList[index]);
    mockWorkSheets.Setup(m => m.GetEnumerator())
        .Returns(() => fakeWorkSheetsList.GetEnumerator());
    //Assuming a Count property exists
    mockWorkSheets.Setup(m => m.Count).Returns(fakeWorkSheetsList.Count);
    //Workbook
    var mockWorkbook = new Mock<IWorkbook>();
    mockWorkbook.Setup(p => p.Name).Returns("Name");
    mockWorkbook.Setup(p => p.FullName).Returns("FullName");
    mockWorkbook.Setup(p => p.Worksheets).Returns(mockWorkSheets.Object);
    //Workbooks
    var fakeWorkbooksList = new List<IWorkbook>() { mockWorkbook.Object };
    var mockWorkbooks = new Mock<IWorkbooks>();
    mockWorkbooks.Setup(m => m[It.IsAny<int>()])
        .Returns<int>(index => fakeWorkbooksList[index]);
    mockWorkbooks.Setup(m => m.GetEnumerator())
        .Returns(() => fakeWorkbooksList.GetEnumerator());
    mockWorkbooks.Setup(m => m.Count).Returns(fakeWorkbooksList.Count);
    //WorkbookSet
    var mockWorkbookSet = new Mock<IWorkbookSet>();
    mockWorkbookSet.Setup(m => m.Workbooks).Returns(mockWorkbooks.Object);
    var workbookSet = mockWorkbookSet.Object;
    var expectedWorkBooksIndex = 0;
    var expectedWorkSheetIndex = 1;
    var expected = fakeWorkSheetsList[expectedWorkSheetIndex];
    //Act
    var actual = workbookSet
        .Workbooks[expectedWorkBooksIndex]
        .Worksheets[expectedWorkSheetIndex];
    //Assert
    Assert.AreEqual(expected, actual);
    foreach (IWorkbook workbook in workbookSet.Workbooks) {
        Assert.IsTrue(workbook.Worksheets.Count > 0);
    }
}

也许你正在寻找这个?

mockWorkbook.SetupGet(wb => wb.Worksheets[i]).Returns(() => worksheetMockList[i]);
相关文章：