使用Moq模拟自定义收藏

Question

I have the following types in a 3rd party library

public interface IWorkbook : IPrintable
{
    ...
    IWorksheets Worksheets { get; }
}

The worksheets interface is

public interface IWorksheets : IEnumerable
{
    IWorksheet this[int index] { get; }
    IWorksheet this[string name] { get; }
    IWorkbookSet WorkbookSet { get; }
    IWorksheet Add();
    IWorksheet AddAfter(ISheet sheet);
    IWorksheet AddBefore(ISheet sheet);
    bool Contains(IWorksheet worksheet);
}

I have a method that I want to unit test that takes an IWorkbook and iterates through the contained worksheets. My problem is how I can use Moq to create a mock collection for IWorksheets . The IWorksheet interface is

public IWorksheet
{
    ...
    public Name { get; set; } // This is the only property I am interested in.
}

So how can I generate a fake IWorkbook which has a fake collection ( IWorksheets ) of IWorksheet s?

I have started out with

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

    List<IMock<IWorksheet>> sheetMockList = new List<IMock<IWorksheet>>();
    foreach (string name in fakeSheetNames)
    {
        Mock<IWorksheet> tmpMock = new Mock<IWorksheet>();
        tmpMock.Setup(p => p.Name).Returns(name);
        sheetMockList.Add(tmpMock);
    }

    var mockWorksheets = new Mock<IWorksheets>();
    mockWorksheets.Setup(p => p).Returns(sheetMockList);
    ...
}

But I cannot do this as (obviously)

cannot convert from 'System.Collections.Generic.List>' to 'SpreadsheetGear.IWorksheets'

How can I mock the IWorksheets collection?

---

So I now have the following code to create my mocks as per the answer below

    [TestClass]
public class WorkbookStrucutreProviderTests
{
    private Mock<IWorkbookSet> mockWorkbookSet;
    private readonly List<string> parentPrefixes = new List<string>() { "__", "wsg" };

    [TestInitialize]
    public void Initialize()
    {
        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);
        }

        List<IWorkbook> workbookMockList = new List<IWorkbook>();
        Mock<IWorkbook> mockWorkbook = new Mock<IWorkbook>();
        mockWorkbook
            .Setup(p => p.Worksheets.GetEnumerator())
            .Returns(worksheetMockList.GetEnumerator());
        workbookMockList.Add(mockWorkbook.Object);

        mockWorkbookSet = new Mock<IWorkbookSet>();
        mockWorkbookSet
            .Setup(p => p.Workbooks.GetEnumerator())
            .Returns(workbookMockList.GetEnumerator());
    }

    [TestMethod]
    public async Task StrucutreGenerationAsyncTest()
    {
        WorkbookStructureProvider provider = new WorkbookStructureProvider();
        await provider.GenerateWorkbookStructureAsync(mockWorkbookSet.Object);

        foreach (var item in provider.Structure)
        {
            Trace.WriteLine("--" + item.Name);
            if (item.HasChildren)
            {
                foreach (var child in item.Children)
                {
                    Trace.WriteLine("-- --" + child.Name);
                }
            }
        }
    }

But in the GenerateWorkbookStructureAsync() method I have this bit of code

bool IsUserCostWorkbook = false;
if (workbook.Worksheets.Cast<IWorksheet>().Any(
    ws => ws.Name.CompareNoCase(Keywords.Master)))
{
    // TODO Extra check for UserCost template.
    IsUserCostWorkbook = true;          
}

and here the workbook.Worksheets collection is empty. I thought my mock GetEnumerator would handle this; it doesn't.

So how can I mock the IWorksheets so that I can do the following?

foreach (var ws in workbook.Worksheets.Cast<IWorksheet>())
{
    ...
}

Answer 1

The following example passes when tested

[TestMethod]
public void Mock_Custom_Collection_Using_Moq() {
    //Arrange
    var parentPrefixes = new List<string>() { "__", "wsg" };
    var fakeSheetNames = new List<string>(){
        "Master",
        "A",
        "B",
        "C",
        "__ParentA", 
        "D",
        "wsgParentB", 
        "E",
        "F",
        "__ParentC",
        "__ParentD",
        "G"
    };

    var worksheetMockList = new List<IWorksheet>();
    foreach (string name in fakeSheetNames) {
        var worksheet = Mock.Of<IWorksheet>();
        worksheet.Name = name;
        worksheet.Visible = parentPrefixes.Any(p => name.StartsWith(p)) ?
                SheetVisibility.Hidden :
                SheetVisibility.Visible;

        worksheetMockList.Add(worksheet);
    }

    var mockWorkbook = new Mock<IWorkbook>();
    mockWorkbook
        .Setup(p => p.Worksheets.GetEnumerator())
        .Returns(() => worksheetMockList.GetEnumerator());

    var workbook = mockWorkbook.Object;

    //Act
    bool IsUserCostWorkbook = false;
    if (workbook.Worksheets.Cast<IWorksheet>()
        .Any(ws => ws.Name.Equals("Master", StringComparison.InvariantCultureIgnoreCase))) {
        IsUserCostWorkbook = true;
    }

    //Assert            
    Assert.IsTrue(IsUserCostWorkbook);
}

Answer 2

Sorry for pseudo code:

var fakeWorksheet = new Mock<IWorksheet>();
//You can use AutoFixture here to auto-populate properties or you can set only required props
fakeWorksheet.Setup(p => p.Name).Returns("TestName");
var worksheetsMock = new Mock<IWorksheets>()
//here mock some members that you need
worksheetsMock.Setup(w => w.Add()).Returns(fakeWorksheet.Object);
var workbookMock = new Mock<IWorkbook>();
workbookMock.Setup(w => w.Worksheets).Returns(worksheetsMock.Object);