从 IReadOnlyCollection 继承的模拟类

Question

I would like to mock a class which inherits from IReadOnlyCollection. I have written some example code to demonstrate my issue. Two out of the Three Asserts work.

When I cast mocked IRemainingSteps to a list or use LINQ the list is empty.

Please, can you explain how I should change the setup of the GetEnumerator to allow all three Asserts to pass.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Moq;
using NUnit.Framework;

namespace BranchScript.UT
{
    [TestFixture]
    public class Steps
    {
        [Test]
        public void Test()
        {
            // Arrange
            string branchA = "branch a";
            string branchB = "branch b";

            var mockStep1 = new Mock<IRemainingStep>();
            mockStep1.Setup(x => x.StepNotes).Returns(branchA);

            var mockStep2 = new Mock<IRemainingStep>();
            mockStep2.Setup(x => x.StepNotes).Returns(branchB);

            var mockStep3 = new Mock<IRemainingStep>();
            mockStep3.Setup(x => x.StepNotes).Returns(branchA);

            var mockStep4 = new Mock<IRemainingStep>();
            mockStep4.Setup(x => x.StepNotes).Returns(branchB);

            List<IRemainingStep> mockStepList = new List<IRemainingStep>
            {
                mockStep1.Object,
                mockStep2.Object,
                mockStep3.Object,
                mockStep4.Object
            };

            var refs = new Mock<IRemainingSteps>(MockBehavior.Strict);
            refs.Setup(r => r.GetEnumerator()).Returns(mockStepList.GetEnumerator());
            refs.As<IEnumerable>().Setup(r => r.GetEnumerator()).Returns(mockStepList.GetEnumerator());

            var mockPlate = new Mock<IPlate>();
            mockPlate.Setup(x => x.RemainingSteps).Returns(refs.Object);

            // Assert
            Assert.AreEqual(branchA, mockPlate.Object.RemainingSteps.First().StepNotes); // Pass
            Assert.AreEqual(branchB, mockPlate.Object.RemainingSteps.Last().StepNotes); // Pass
            Assert.AreEqual(2, mockPlate.Object.RemainingSteps.Where(x => x.StepNotes == branchA).Count()); // Fail
        }
    }

    public interface IRemainingSteps : IReadOnlyCollection<IRemainingStep>
    {
    }

    public interface IRemainingStep : IStep
    {
    }

    public interface IStep
    {
        string StepNotes { get; }
    }

    public interface IPlate
    {
        IRemainingSteps RemainingSteps { get; }
    }
}

Answer 1

Passing back the Enumerator only allow one read, because it is forward only.

var refs = new Mock<IRemainingSteps>(MockBehavior.Strict);
refs.Setup(r => r.GetEnumerator()).Returns(mockStepList.GetEnumerator());
refs.As<IEnumerable>().Setup(r => r.GetEnumerator()).Returns(mockStepList.GetEnumerator());

But if the mock returns a function it will allow for repeated calls to the enumerator

var refs = new Mock<IRemainingSteps>(MockBehavior.Strict);
refs.Setup(r => r.GetEnumerator()).Returns(() => mockStepList.GetEnumerator());
refs.As<IEnumerable>().Setup(r => r.GetEnumerator()).Returns(() => mockStepList.GetEnumerator());

Note the use of the function call in the Returns

.Returns(() => mockStepList.GetEnumerator())

The first two assertion work as you are still moving forward in the enumerator.

Assert.AreEqual(branchA, mockPlate.Object.RemainingSteps.First().StepNotes); // Pass
Assert.AreEqual(branchB, mockPlate.Object.RemainingSteps.Last().StepNotes); // Pass

By the third assertion the pointer is already at the end

Assert.AreEqual(2, mockPlate.Object.RemainingSteps.Where(x => x.StepNotes == branchA).Count()); // Fail

so the count will not be as expected.