FakeItEasy | The easy mocking library for .NET | Mock library

type MyType () = 
    abstract B: ?s:string -> unit
    default x.B (?s: string) = Option.iter (printfn "Implemented: %s") s

[]
let doit () = 
    let a = A.Fake()
    A.CallTo(fun () -> a.B(ignored())).Invokes(fun s -> Option.iter (printfn "Faked: %s") s)
    a.B "Hello"

var fakeConnection = A.Fake();
var fakeResolver = A.Fake();
var logger = A.Fake>();

var repository = new DummyAggregateRepository(fakeConnection, fakeResolver, logger);

var fakeRepository = A.Fake(
    o =>
    {
        o.Wrapping(repository);
        o.Strict();
    });

var aggregateId = Guid.NewGuid();

A.CallTo(() => fakeRepository.GetById(aggregateId, A._))
    .CallsWrappedMethod();

var fixture = new AutoFixture.Fixture();

var events1 = fixture.CreateMany(10).Cast();
var events2 = fixture.CreateMany(10).Cast();

var events = events1.Union(events2).ToList();

A.CallTo(
        () => fakeRepository.GetEvents(
            "dummyAggregate-" + aggregateId.ToString("N"),
            aggregateId.ToString(),
            A._))
    .Returns(events);

var aggregate = await fakeRepository.GetById(aggregateId, default);

public virtual async Task GetById(Guid aggregateId, CancellationToken ct)
        {
            ct.ThrowIfCancellationRequested();

            var streamName = this.GetStreamName(aggregateId);

            using var scope = EventStoreCommon.CreateScope(Tracer.Instance, nameof(this.GetById), streamName);

            var events = await this.GetEvents(streamName, aggregateId.ToString(), ct);

            if (events.Any() == false)
            {
                throw new AggregateNotFoundException(aggregateId, typeof(TAggregate));
            }

            var aggregate = new TAggregate();

            foreach (var @event in events)
            {
                aggregate.ApplyEvent(@event);
            }

            return aggregate;
        }

FakeItEasy.ExpectationException: Call to unconfigured method of strict fake: MyCompany.EventStore.Test.AggregateRepositoryTests.DummyAggregateRepository...

FakeItEasy.ExpectationException
Call to unconfigured method of strict fake: MyCompany.EventStore.Test.AggregateRepositoryTests.DummyAggregateRepository.GetById(aggregateId: d8d0445d-7f82-4636-82fc-2e8f14be7f3d, ct: System.Threading.CancellationToken).
   at FakeItEasy.Core.StrictFakeRule.Apply(IInterceptedFakeObjectCall fakeObjectCall) in C:\projects\fakeiteasy\src\FakeItEasy\Core\StrictFakeRule.cs:line 53
   at FakeItEasy.Core.FakeManager.ApplyBestRule(IInterceptedFakeObjectCall fakeObjectCall) in C:\projects\fakeiteasy\src\FakeItEasy\Core\FakeManager.cs:line 276
   at FakeItEasy.Core.FakeManager.FakeItEasy.Core.IFakeCallProcessor.Process(InterceptedFakeObjectCall fakeObjectCall) in C:\projects\fakeiteasy\src\FakeItEasy\Core\FakeManager.cs:line 178
   at FakeItEasy.Creation.CastleDynamicProxy.CastleDynamicProxyGenerator.ProxyInterceptor.Intercept(IInvocation invocation) in C:\projects\fakeiteasy\src\FakeItEasy\Creation\CastleDynamicProxy\CastleDynamicProxyGenerator.cs:line 187
   at Castle.DynamicProxy.AbstractInvocation.Proceed()
   at Castle.Proxies.DummyAggregateRepositoryProxy.GetById(Guid aggregateId, CancellationToken ct)
   at MyCompany.EventStore.Test.AggregateRepositoryTests.GetByIdTests.When_Stream_Exists_Should_Create_Instance_Of_Aggregate_With_Applied_Events() in C:\github\MyCompany_2\libraries\eventstore\test\MyCompany.EventStore.Test\AggregateRepositoryTests\GetByIdTests.cs:line 131
   at System.Threading.Tasks.Task.<>c.b__139_0(Object state)
   at Xunit.Sdk.AsyncTestSyncContext.<>c__DisplayClass7_0.b__1(Object _) in C:\Dev\xunit\xunit\src\xunit.execution\Sdk\AsyncTestSyncContext.cs:line 75

"SettingsConfig": [
{
  "Name": "Something",
  "Node": "Something",
  "SettingName": "Something"
},
{
  "Name": "Something",
  "Node": "Something",
  "SettingName": "Something"
}]

_configuration = A.Fake();
A.CallTo(() => _configuration.GetSection("SettingsConfig")).Returns(new List());

class SearchEngine
{
    public void Search()
    {
        var module = new SearchModule();
        module.Search();
    }
}

    event Action DownloadFinished;

fakeObject.DownloadFinished  = Raise.With();

public static IAnyCallConfigurationWithReturnTypeSpecified ReturnForMethod(
          this Fake fake,
           string methodName, ReturnType returnObj)
      {
          var call = fake.AnyCall().WithReturnType().Where(s => s.Method.Name == methodName);

          call.Returns(returnObj);
          return call;
      }

//Called using 
new Fake().ReturnForMethod(nameof(IDummyFactory.Create), testStr);

public static IAnyCallConfigurationWithReturnTypeSpecified ReturnForMethodF(
            this Fake fake,
            MethodGroup method, ReturnType returnObj)

new Fake().ReturnForMethod(s=> s.Create, testStr); --NoInvoke as just want method group

AutoFixture.ObjectCreationExceptionWithPath : AutoFixture was unable to create an instance from Microsoft.Extensions.Logging.ILogger`1[MyAPI.Controllers.CustomerController] because it's an interface. There's no single, most appropriate way to create an object implementing the interface, but you can help AutoFixture figure it out.
    
    If you have a concrete class implementing the interface, you can map the interface to that class:
    
    fixture.Customizations.Add(
        new TypeRelay(
            typeof(Microsoft.Extensions.Logging.ILogger`1[MyAPI.Controllers.CustomerController]),
            typeof(YourConcreteImplementation)));
    
    Alternatively, you can turn AutoFixture into an Auto-Mocking Container using your favourite dynamic mocking library, such as Moq, FakeItEasy, NSubstitute, and others. As an example, to use Moq, you can customize AutoFixture like this:
    
    fixture.Customize(new AutoMoqCustomization());
    
    See http://blog.ploeh.dk/2010/08/19/AutoFixtureasanauto-mockingcontainer for more details.

[Theory, AutoMoqData, AutoMapperData(typeof(MappingProfile))]
public async Task GetCustomers_ShouldReturnCustomers_WhenGivenCustomers(
  [Frozen] Mock mockMediator,
  List customers,
  [Greedy] CustomerController sut,
  GetCustomersQuery query
)
{
    //Arrange
    var dto = new GetCustomersDto
    {
      TotalCustomers = customers.Count,
      Customers = customers
    };

    mockMediator.Setup(x => x.Send(It.IsAny(), It.IsAny()))
    .ReturnsAsync(dto);

    //Act
    var actionResult = await sut.GetCustomers(query);

    //Assert
    var okObjectResult = actionResult as OkObjectResult;
    okObjectResult.Should().NotBeNull();

    var response = okObjectResult.Value as Models.GetCustomers.GetCustomersResult;
    response.TotalCustomers.Should().Be(customers.Count);
    response.Customers.Count.Should().Be(customers.Count);
    response.Customers[0].AccountNumber.Should().Be(customers[0].AccountNumber);
    response.Customers[1].AccountNumber.Should().Be(customers[1].AccountNumber);
}

    public class AutoMapperDataAttribute : AutoDataAttribute
    {
        public AutoMapperDataAttribute(Type type)
          : base(() => new Fixture().Customize(new AutoMapperCustomization(CreateMapper(type))))
        {
        }

        private static IMapper CreateMapper(Type profileType)
        {
            return new MapperConfiguration(opts =>
            {
                opts.AddProfile(profileType);
            })
            .CreateMapper();
        }
    }

    public class AutoMapperCustomization : ICustomization
    {
        private readonly IMapper mapper;
        public AutoMapperCustomization(IMapper mapper) => this.mapper = mapper;

        public void Customize(IFixture fixture)
        {
            fixture.Inject(mapper);
        }
    }

        [HttpPost]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status201Created)]
        public async Task Post(CreateOwnerRequest requestModel)
        {
            var command = new CreateOwnerCommand { RequestModel = requestModel };
            var ownerResponse = await _mediator.Send(command, default);
                       
            //TODO: return URI for the new resources
            return Created("", ownerResponse);
        }

        [Theory]
        [ClassData(typeof(ValidCreateOwnerTestData))]
        public async void ShouldCallCreateOwnerHandler(CreateOwnerRequest validCreateOwnerModel)
        {
            // Arrange
            var fakeMediator = A.Fake();
            A.CallTo(() => fakeMediator.Send(new CreateOwnerCommand { RequestModel = validCreateOwnerModel },
                default)).Returns(A.Dummy>());
            var ownerController = new OwnerController(fakeMediator);

            // Act
            _ = await ownerController.Post(validCreateOwnerModel);

            // Assert
            A.CallTo(() => fakeMediator.Send(new CreateOwnerCommand { RequestModel = validCreateOwnerModel },
                default)).MustHaveHappened();
        }

    public class ValidCreateOwnerTestData : IEnumerable
    {
        public IEnumerator GetEnumerator()
        {
            yield return new object[] { new CreateOwnerRequest { FirstName = "Foo", LastName = "Bar" } };
        }

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
    }

public abstract class BaseClass
    {
        public void Do()
        {
            Do_Override();
        }

        protected abstract void Do_Override();
    }

  public class ImplementingClass: BaseClass
    {
        protected override void Do_Override()
        {
            ProtectedDo();
        }

        protected virtual void ProtectedDo()
        {

        }        
    }

 public class ImplementingClassShould
    {
        [Fact]
        public void Run_ProtectedDo()
        {
            var fake = A.Fake();
            fake.Do();
            A.CallTo(fake).Where(_ => _.Method.Name == "ProtectedDo").MustHaveHappened();

        }
     }

 public class ImplementingClassShould
    {    
        [Fact]
        public void Run_ProtectedDo_V2()
        {
            var sut = new ImplementingClass();
            var sutFakeWrapper = A.Fake(_ => _.Wrapping(sut));
            sutFakeWrapper.Do();
            A.CallTo(sutFakeWrapper).Where(_ => _.Method.Name == "ProtectedDo").MustHaveHappened();

        }        
    }