Setup for testing a Linq query on a LinqToExcel IExcelQueryFactory

Question

Using c#, Moq, MSTest, LinqToExcel

I'm having trouble figuring out the best way to Setup() a mock for a response from a Linq query on a Linq-to-Excel IExcelQueryFactory.

I think I should expect the Linq Query to return something of type delegate, but I'm not quite sure what that should look like

Can anyone suggest what my Return() should look like in the Moq Setup() below?

Also, any toughts on my approach to testing and mocking these Lynq methods? Should I be approaching this differently?

Thanks! I'm going to go book up on delegates now. :)

The Test

[TestClass]
public class ThingsSheetTests
{
    [TestMethod]
    public void GetRows_ReturnsListOfThings()
    {
        // Arrange
        var mockExcelQueryFactory = new Mock<IExcelQueryFactory>();
        var thingsSheet = new ThingsSheet(mockExcelQueryFactory.Object, "file", "worksheet");

        mockExcelQueryFactory
        .Setup(x => x.Worksheet<Thing>(It.IsAny<string>))

        // I think this is correctly casting to a delegate
        // however ExelQuerable constructor needs arguments:
        // public ExcelQueryable(IQueryProvider provider, Expression expression);
        // looking into what kind of IQueryProvider and Expression I should supply.

        .Returns(Action(() => new ExcelQueryable<Thing> { }));   // getting closer!


        // Act
        thingsSheet.GetRows();

        // Assert
        mockExcelQueryFactory.Verify();

    }
}

The Class and Method I'm testing

public class ThingsSheet
{
    private string importFile;
    private string worksheetName;
    private IExcelQueryFactory excelQueryFactory;
    public ThingsSheet(IExcelQueryFactory excelQueryFactory, string importFile, string worksheetName)
    {
        this.excelQueryFactory = excelQueryFactory;
        this.importFile = importFile;
        this.worksheetName = worksheetName;
        this.AddMappings();
    }

    private void AddMappings()
    {
        excelQueryFactory.AddMapping<Thing>(t => t.Id, "Thing ID");
    }

    public List<Thing> GetRows()
    {
        excelQueryFactory.AddMapping<Thing>(t => t.Id, "Thing ID");

        var things = from thing in excelQueryFactory.Worksheet<Thing>(this.worksheetName)
                   select new Thing { };

        return things.ToList<Thing>();
    }
}

Answer 1

You can use e.g. a method which returns your fake data.

mockExcelQueryFactory
    .Setup(x => x.Worksheet<Thing>(It.IsAny<string>()))
    .Returns(ExcelQueryableOfThing()); 

Lets say Thing class looks like this:

public class Thing
{
    public string Id { get; set; }
    public string Name { get; set; }
}

Then in the method ExcelQueryableOfThing() you have to mock the CreateQuery<TElement>(Expression expression) method of IQueryProvider provider. Something like this:

private ExcelQueryable<Thing> ExcelQueryableOfThing()
{
    var things = new List<Thing>
    {
        new Thing
        {
            Id = "1",
            Name = "Adam"
        },
        new Thing
        {
            Id = "1",
            Name = "Eva"
        }
    }
    .AsQueryable();

    Mock<IQueryProvider> queryProvider = new Mock<IQueryProvider>();
    queryProvider
        .Setup(p => p.CreateQuery<Thing>(It.IsAny<Expression>()))
        .Returns(() => things);

    Expression expressionFake = Expression.Constant(new List<Thing>().AsQueryable());

    return new ExcelQueryable<Thing>(queryProvider.Object, expressionFake);
}

Then in the unit test thingsSheet.GetRows() will return your fake data (Adam and Eva :). HTH

[TestMethod]
public void GetRows_ReturnsListOfThings()
{
    // Arrange
    Mock<IExcelQueryFactory> mockExcelFile = new Mock<IExcelQueryFactory>();
    var thingsSheet = new ThingsSheet(mockExcelFile.Object, "file", "worksheet");

    mockExcelFile
        .Setup(x => x.Worksheet<Thing>(It.IsAny<string>()))
        .Returns(ExcelQueryableOfThing());

    // Act
    List<Thing> rows = thingsSheet.GetRows();

    // Assert
    Assert.AreEqual(2, rows.Count); // Adam and Eva
}