How to mock an SqlDataReader using Moq - Update

This does not let you mock a SqlDataReader but if your function is returning a DbDataReader (The base class of SqlDataReader) or a IDataReader the easist way to mock it is just use a DataTable or a DataSet and call its CreateDataReader() function and return that.

First, in a separate project, run your query like normal to produce some test data and use the WriteXmlSchema to generate a .xsd file and the WriteXml functions to hold the test data.

using (var con = new SqlConnection(connectionString))
{
    con.Open();
    using (var cmd = new SqlCommand("Some query", con))
    {

        DataSet ds = new DataSet("TestDataSet");
        DataTable dt = new DataTable("FirstSet");
        ds.Tables.Add(dt);
        using (var reader = cmd.ExecuteReader())
        {
            dt.Load(reader);
        }

        ds.WriteXmlSchema(@"C:\Temp\TestDataSet.xsd");
        ds.WriteXml(@"C:\Temp\TestDataSetData.xml");
    }
}

In your test project add TestDataSet.xsd to the project and make sure it has the custom tool of MSDataSetGenerator (it should have it by default). This will cause a DataTable derived class named TestDataSet to be generated that has the schema of your query.

Then add TestDataSetData.xml as a resource to your test project. Finally in your test create the TestDataSet and call ReadXml using the text from the xml file you generated.

var resultSet = new TestData.TestDataSet();
using (var reader = new StringReader(Resources.TestDataSetData))
{
    resultSet.ReadXml(reader);
}

var testMock = new Mock<DbCommand>();

testMock.Setup(x => x.ExecuteReader())
    .Returns(resultSet.CreateDataReader);

testMock.Setup(x => x.ExecuteReaderAsync())
    .ReturnsAsync(resultSet.CreateDataReader);

This will create a data reader that will act just like the data reader that would have been returned from the sql query and even supports things like multiple result sets returned.

Moq has an ability to run some code after the method is executed. It is called "Callback". Modify your code this way and it will work:

private IDataReader MockIDataReader()
{
    var moq = new Mock<IDataReader>();

    bool readToggle = true;

    moq.Setup(x => x.Read())
         // Returns value of local variable 'readToggle' (note that 
         // you must use lambda and not just .Returns(readToggle) 
         // because it will not be lazy initialized then)
        .Returns(() => readToggle) 
        // After 'Read()' is executed - we change 'readToggle' value 
        // so it will return false on next calls of 'Read()'
        .Callback(() => readToggle = false); 

    moq.Setup(x => x["Char"])
        .Returns('C');

    return moq.Object;
}

private class TestData
{
    public char ValidChar { get; set; }
}

private TestData GetTestData()
{
    var testData = new TestData();

    using ( var reader = MockIDataReader() )
    {
       testData = new TestData
       {
           ValidChar = (Char)reader["Char"]
       };
   }

   return testData;
}

But what if it will be required IDataReader to contain not only single row, but several? Well, here is a sample:

// You should pass here a list of test items, their data
// will be returned by IDataReader
private IDataReader MockIDataReader(List<TestData> ojectsToEmulate)
{
    var moq = new Mock<IDataReader>();

    // This var stores current position in 'ojectsToEmulate' list
    int count = -1;

    moq.Setup(x => x.Read())
        // Return 'True' while list still has an item
        .Returns(() => count < ojectsToEmulate.Count - 1)
        // Go to next position
        .Callback(() => count++);

    moq.Setup(x => x["Char"])
        // Again, use lazy initialization via lambda expression
        .Returns(() => ojectsToEmulate[count].ValidChar);

    return moq.Object;
}

I was just trying to figure this out myself. Not sure if this is new functionality in Moq, but it appears there is a simpler way than @Monsignor's answer.

Use Moq's SetupSequence method. Your code simply becomes:

private IDataReader MockIDataReader()
{
    var moq = new Mock<IDataReader>();
    moq.SetupSequence( x => x.Read() )
       .Returns( true )
       .Returns( false );
    moq.SetupGet<object>( x => x["Char"] ).Returns( 'C' );

    return moq.Object; 
}