Feature request: ReturnsNextFromSequenceLazily() about fakeiteasy HOT 6 CLOSED

using FakeItEasy.Configuration;
using FakeItEasy.Core;

namespace FIEQuestions;

public class Test
{

    public interface IDoSomething
    {
        int Foo(int x);
    }

    private int ProduceValue1(IFakeObjectCall call) => 2 * call.GetArgument<int>(0);

    private int ProduceValue2(IFakeObjectCall call) => call.GetArgument<int>(0) * call.GetArgument<int>(0);

    [Fact]
    public void TestWithExplicitQueue()
    {
        var fake = A.Fake<IDoSomething>();

        var valueProducers = new Queue<Func<IFakeObjectCall, int>>(new[] { ProduceValue1, ProduceValue2 });

        A.CallTo(() => fake.Foo(A<int>._)).ReturnsLazily(call => valueProducers.Dequeue()(call));

        var result1 = fake.Foo(6);
        var result2 = fake.Foo(-17);

        result1.Should().Be(12);
        result2.Should().Be(289);
        // if we picked the 3rd one, we'd walk off the end of the queue; not great
        // but I'm not sure what your switch does either
    }

    [Fact]
    public void TestWithCustomRule()
    {
        var fake = A.Fake<IDoSomething>();
        Fake.GetFakeManager(fake).AddRuleFirst(new MyRule(ProduceValue1, ProduceValue2));

        var result1 = fake.Foo(6);
        var result2 = fake.Foo(-17);
        var result3 = fake.Foo(7);

        result1.Should().Be(12);
        result2.Should().Be(289);
        result3.Should().Be(0);
    }

    [Fact]
    public void TestWithCustomExtensionMethod()
    {
        var fake = A.Fake<IDoSomething>();
        A.CallTo(() => fake.Foo(A<int>._)).ReturnsNextFromSequenceLazily(ProduceValue1, ProduceValue2);

        var result1 = fake.Foo(6);
        var result2 = fake.Foo(-17);
        var result3 = fake.Foo(7);

        result1.Should().Be(12);
        result2.Should().Be(289);
        result3.Should().Be(0);
    }

    class MyRule : IFakeObjectCallRule
    {
        public MyRule(params Func<IFakeObjectCall, int>[] valueProducers)
        {
            this.valueProducers = new Queue<Func<IFakeObjectCall, int>>(valueProducers);
            this.NumberOfTimesToCall = valueProducers.Length;
        }

        public int? NumberOfTimesToCall { get; init; }

        Queue<Func<IFakeObjectCall, int>> valueProducers;

        public void Apply(IInterceptedFakeObjectCall fakeObjectCall)
            => fakeObjectCall.SetReturnValue(
                this.valueProducers.Dequeue()(fakeObjectCall));

        public bool IsApplicableTo(IFakeObjectCall fakeObjectCall) =>
             fakeObjectCall.Method.GetParameters().Length == 1
                && fakeObjectCall.Method.GetParameters()[0].ParameterType == typeof(int)
                && fakeObjectCall.Method.ReturnType == typeof(int);
    }
}

public static class ReturnValueConfigurationExtensions
{
    public static IThenConfiguration<FakeItEasy.Configuration.IReturnValueConfiguration<T>> ReturnsNextFromSequenceLazily<T>(
        this IReturnValueConfiguration<T> configuration, params Func<IFakeObjectCall, T>[] producers)
    {
        for (int i = 0; i < producers.Length - 1; i++)
        {
            configuration = configuration.ReturnsLazily(producers[i]).Once().Then;
        }
        return configuration.ReturnsLazily(producers[producers.Length - 1]).Once();
    }
}

// MY WORKAROUND:
int call = 1;
A.CallTo(() => foo.Bar()).ReturnsLazily(x =>
{
    switch(call)
    {
        case 1: return ProduceValue1(x);
        case 2: return ProduceValue2(x);
        ...
    }
    ++call;
});

// ENVISIONED API:
A.CallTo(() => foo.Bar()).ReturnsNextFromSequenceLazily(ProduceValue1, ProduceValue2);