在 FakeItEasy 中伪造一个枚举器

Question

如何使用 FakeItEasy 创建一个允许在连续调用时返回不同值的假值。这是我希望能够做的一个示例：

var enumerator = A.Fake<IDictionaryEnumerator>();
A.CallTo(() => enumerator.MoveNext()).Returns(true);  //Expected value for first call
A.CallTo(() => enumerator.Key).Returns("key1");
A.CallTo(() => enumerator.Value).Returns("value1");
A.CallTo(() => enumerator.MoveNext()).Returns(false); //Expected value for second call

Assert.IsTrue(enumerator.MoveNext());    //Fails
Assert.IsFalse(enumerator.MoveNext());   

断言将失败，因为 MoveNext 的最后一次设置将覆盖第一个设置。

是否可以在 FakeItEasy 中执行我想要的操作？

。

[编辑]
澄清了原始问题的示例并在下面提供了一个工作示例。

根据帕特里克的回答，此代码显示了如何设置假的。诀窍是反转所有设置并使用 Once()。

var enumerator = A.Fake<IDictionaryEnumerator>();
A.CallTo(() => enumerator.MoveNext()).Returns(false).Once();
A.CallTo(() => enumerator.MoveNext()).Returns(true).NumberOfTimes(2);
A.CallTo(() => enumerator.Key).Returns("key2").Once();
A.CallTo(() => enumerator.Value).Returns("value2").Once();
A.CallTo(() => enumerator.Key).Returns("key1").Once();
A.CallTo(() => enumerator.Value).Returns("value1").Once();

while(enumerator.MoveNext())
{
    Debug.WriteLine(enumerator.Key + ": "+ enumerator.Value);               
}

这将打印：

key1: value1
key2: value2

Answer 1

我不完全确定我理解你的意思，你提供的代码总是会失败。但是，如果您的意思是希望它在调用时第二次返回 true，则可以完成。我可以想到几种不同的方法，其中两种是：

A.CallTo(() => enumerator.MoveNext()).ReturnsNextFromSequence(false, true);

另一种方法是：

A.CallTo(() => enumerator.MoveNext()).Returns(true);
A.CallTo(() => enumerator.MoveNext()).Returns(false).Once();

编辑：

第二，虽然我想我更好地理解你的问题，但你想要发生的是MoveNext 第一次应该返回 true，第二次返回 false？如果是这种情况，只需更改上面示例中值的顺序即可。

FakeItEasy 不使用记录/重播模型，您是正确的，因为最新配置的规则优先于任何早期指定的规则。这就是为什么您必须在最新配置上指定重复“.Once()”，使其仅有效一次。

最新优先的原因有很多，最重要的原因之一是它允许您在夹具的设置中设置默认返回值，并覆盖它以在某些测试中返回特定值，这在以下情况下是不可能的：使用记录/重放模型。

Answer 2

OP 基于帕特里克答案的示例很好......但如果序列变大，就会很乏味。为了补充这个答案，请考虑即使假/模拟示例通常显示一堆直线代码来自行排列，但您实际上拥有编程语言的全部功能。条件、循环，甚至过程。

因此，请考虑以下内容：

public static void AFakeDictionaryEnumeratorReturns(
                       IDictionaryEnumerator enumerator, params object[] pairs)
{
    if (0 != pairs.Length % 2)
        throw new ArgumentException("pairs must have even number of elements", "pairs");

    int n = pairs.Length / 2;

    A.CallTo(() => enumerator.MoveNext()).Returns(false).Once();
    A.CallTo(() => enumerator.MoveNext()).Returns(true).NumberOfTimes(n);

    for (int i = pairs.Length; i > 0; i -= 2)
    {
        A.CallTo(() => enumerator.Key).Returns(pairs[i - 2]).Once();
        A.CallTo(() => enumerator.Value).Returns(pairs[i - 1]).Once();
    }
}

现在测试变为：（

var enumerator = A.Fake<IDictionaryEnumerator>();
AFakeDictionaryEnumeratorReturns(enumerator, 
                                 "key1", "value1", "key2", "value2", "key3", "value3");

var keys = new List<object>();
var values = new List<object>();
while (enumerator.MoveNext())
{
    keys.Add(enumerator.Key);
    values.Add(enumerator.Value);
}

Assert.Equal(new List<object> { "key1", "key2", "key3" }, keys);
Assert.Equal(new List<object> { "value1", "value2", "value3" }, values);

IDictionaryEnumerator 成对处理，因此此示例并不明显有益。对于标准 IEnumerator< /code> 一个静态泛型方法可以为一大堆不同的枚举器服务。）