FakeItEasy - Expected to find it once or more but no calls were made to the fake object

Question

I have an event creation method that should return me an object EventoDto, I'm using fakeiteasy and create the object with values because have a problems with the validations, now this is my code. HOw I should make this test?

[Fact]
public async void CreateEventSuccess_should_return_the_object_created()
{
    var dataEventDto = A.Fake<EventDto>();
    var createEvent = A.Fake<IEventService>();
    var objectEventDtoReturn = new EventDto();
    var eventService = new EventService(this.eventRepository, this.mapper);

    dataEventDto.Title = "this is a test for add event";
    dataEventDto.Description = "this is a description for the add event";
    dataEventDto.Venue = "this is the street";
    dataEventDto.Date = DateTime.Now;
    dataEventDto.Booking = true;
    dataEventDto.TypeEvent = EventType.Presential;
    dataEventDto.State = EventState.Published;
    dataEventDto.CancellationReason = "this is a test of cancellation event";
    dataEventDto.Url = "this is a url";

    A.CallTo(() => createEvent.Add(dataEventDto)).Returns(objectEventDtoReturn);

    await eventService.Add(dataEventDto);

    A.CallTo(() => createEvent.Add(dataEventDto)).MustHaveHappened();
}

the error that this produce is:

   Assertion failed for the following call:
        Assertion failed for the following call:
        Jalasoft.Events.Domain.Interfaces.Services.IService`2[Jalasoft.Events.Services.EventDto,System.String].Add(entity: Faked Jalasoft.Events.Services.EventDto)
      Expected to find it once or more but no calls were made to the fake object.

this is the subject that I'm testing

private readonly IEventRepository repository;
private readonly IMapper mapper;
private EventValidator validator = new EventValidator();

public EventService(IEventRepository repository, IMapper mapper)
{
    this.repository = repository;
    this.mapper = mapper;
}

public async Task<EventDto> Add(EventDto entity)
{
    try
    {
        var results = this.validator.Validate(entity);
        bool success = results.IsValid;
        if (success)
        {
            Event eventMapper = this.mapper.Map<Event>(entity);
            var response = await this.repository.Add(eventMapper);
            EventDto eventDtoMapper = this.mapper.Map<EventDto>(response);
            return eventDtoMapper;
        }
        else
        {
            IList<ValidationFailure> failures = results.Errors;
            throw new ValidationException(failures);
        }
    }
    catch (Exception e)
    {
        throw new NotImplementedException(e.ToString());
    }
}

for mapper I'm using https://automapper.org/

IEventService script

public interface IEventService : IService<EventDto, string>
{
}

Iservice script

public interface IService<T, TId>
    where T : EntityObject<TId>
{
    T GetById(TId id);

    Task<IEnumerable<T>> List();

    Task<T> Add(T entity);

    T Delete(T entity);

    T Edit(T entity);
}

IEventRepository script

public interface IEventRepository : IRepository<Event, ObjectId>
{
}

IRepository script

public interface IRepository<T, TId>
    where T : EntityObject<TId>
{
    T GetById(TId id);

    Task<IEnumerable<T>> List();

    Task<T> Add(T entity);

    T Delete(T entity);

    T Edit(T entity);
}

EventValidator script

        public EventValidator()
        {
            this.RuleFor(x => x.Title)
                .NotNull()
                .Length(10, 50)
                .WithMessage("Title shuold be 50 characteres like Max");
            this.RuleFor(x => x.Description)
                .NotNull()
                .Length(10, 500)
                .WithMessage("Description shuold be 500 characteres like Max");
            this.RuleFor(x => x.Booking)
                .NotNull()
                .WithMessage("Booking not null");
            this.RuleFor(x => x.Date)
                .Must(this.BeAValidDate).
                WithMessage("Is not a valid datetime");
            this.RuleFor(x => x.State == EventState.Cancelled || x.State == EventState.Published)
                .NotNull()
                .WithMessage("Is not a valid state");
            this.RuleFor(x => x.TypeEvent == EventType.Online || x.TypeEvent == EventType.Presential)
                .NotNull()
                .WithMessage("Is not a valid event type");
        }

Answer 1

It appears the current test is trying to mock the subject under test.

Mock only the dependencies necessary to get the subject under test to behave as expected when exercised.

//...

[Fact]
public async Task CreateEventSuccess_should_return_the_object_created() {
    //Arrange

    //Making sure DTO can pass validation.
    var expected = new EventDto();
    expected.Title = "this is a test for add event";
    expected.Description = "this is a description for the add event";
    expected.Venue = "this is the street";
    expected.Date = DateTime.Now;
    expected.Booking = true;
    expected.TypeEvent = EventType.Presential;
    expected.State = EventState.Published;
    expected.CancellationReason = "this is a test of cancellation event";
    expected.Url = "this is a url";

    //mocked repository to verify expected behavior.
    IEventRepository eventRepository = A.Fake<IEventRepository>();
    Event passedEvent = null;
    A.CallTo(() => eventRepository.Add(A<Event>._))
        .Invokes((Event arg) => passedEvent = arg)
        .Returns(passedEvent);

    //Assuming an actual mapper is being used.
    var subject = new EventService(eventRepository, this.mapper);

    //Act
    EventDto actual = await subject.Add(expected);

    //Assert
    A.CallTo(() => eventRepository.Add(A<Event>._)).MustHaveHappened();

    //expected and actual should be equivalent, so that could also be checked

}