Is it possible to have a mix of loose and strict modes?

I’d like mock to behave in a way described in Mark’s article

I’d consider as a command any method returning void/Task/ValueTask, query - for anything else. So, whenever commands are called, I can verify the call, and when query is performed, the exception is thrown unless the result is explicitly defined.

[thomaslevesque]

Ah, I see!

[blairconrad]

Hi, @voroninp. There’s nothing like that built into FakeItEasy itself, and I’m not sure if there’s widespread demand, but it wouldn’t be too hard to configure Fakes in this way. One could make the Fake strict and then override the strictness for the methods one cared about. Here’s a very rough attempt, whose tests pass:

namespace FakeItEasyQuestions
{
    using System.Threading.Tasks;
    using FakeItEasy;
    using FluentAssertions;
    using Xunit;

    public class Test
    {
        public interface IInterface
        {
            int AQuery();
            void ACommand();
        }

        [Fact]
        public void QueryIsStrict()
        {
            var fake = AHalfStrictFake<IInterface>();
            var exception = Record.Exception(() => fake.AQuery());
            exception.Should().NotBeNull();
        }

        [Fact]
        public void CommandIsLoose()
        {
            var fake = AHalfStrictFake<IInterface>();
            fake.ACommand();
            A.CallTo(() => fake.ACommand()).MustHaveHappened();
            
        }

        private static T AHalfStrictFake<T>() where T: class
        {
            var fake = A.Fake<T>(o => o.Strict());
            A.CallTo(fake).WithVoidReturnType().DoesNothing();
            A.CallTo(fake).WithReturnType<Task>().DoesNothing();
            return fake;
        }
    }
}

Of course there are many ways to optimize this. For example, one could apply the configuration via an implicit creation option. Or possibly by adding an IFakeOptions extension. This is how CallsBaseMethods is implemented, in fact.