Type de retour Moq IEnumerable renvoyé sous forme de liste

J'ai du mal à faire en sorte que Moq renvoie les types IEnumerable partir des méthodes de référentiel.

Mise à jour - 1

J'espérais qu'il me manquait quelque chose mais, comme demandé, voici la mise en œuvre complète qui est en place.

L'affirmation que l' objResult.Value est de type IEnumerable<ListItemDTO> est ce qui échoue.

Interface du référentiel

public class TARTrackerControllerTests
{
    public static ILogger<TARTrackerController> Logger = Mock.Of<ILogger<TARTrackerController>>();
    public static Mock<ITARRepository> Repository = new Mock<ITARRepository>();

    public class GetTARTrackersTests
    {
        [Fct]
        public async Task Returns_OK_With_ListItemDTO()
        {
            //arrange
            var id = 12345;
            IEnumerable<ListItemDTO> expected = new List<ListItemDTO>();

            Repository
                .Setup(repo => repo.GetListAsync<ListItemDTO>(It.IsAny<string>(), It.IsAny<object>()))
                .ReturnsAsync(expected);

            var controller = new TARTrackerController(Logger, Repository.Object);

            //act
            var result = await controller.Get(id);

            //assert
            var objResult = Assert.IsType<OkObjectResult>(result);
            Assert.Equal(typeof(IEnumerable<ListItemDTO>), objResult.Value.GetType());
        }
    }
}

Manette

public class TARTrackerController : Controller
{
    private readonly ITARRepository Repository;
    private readonly ILogger<TARTrackerController> Logger;

    public TARTrackerController(ILogger<TARTrackerController> logger, ITARRepository repository) 
    {
        Repository = repository;
        Logger = logger;
    }

    [HttpGet("TARTrackers")]
    [SwaggerResponse(HttpStatusCode.OK, typeof(IEnumerable<ListItemDTO>))]
    [SwaggerResponse(HttpStatusCode.Unauthorized, null)]
    [SwaggerResponse(HttpStatusCode.InternalServerError, null)]
    [SwaggerResponse(HttpStatusCode.ServiceUnavailable, null)]
    [Description("Get TAR Tracker List")]
    public async Task<IActionResult> Get(long accountId)
    {
        try
        {
            var trackers = await Repository.GetListAsync<ListItemDTO>("spFDBGetAccountTARList", new { @ParamAccountID = accountId });

            return Ok(trackers);
        }
        catch (Exception e)
        {
            Logger.LogError(LogEvents.Services, e, $"An error occured in {0}.{1}", nameof(TARTrackerController), nameof(Get));

            return StatusCode((int)HttpStatusCode.InternalServerError);
        }
    }
}

Test de l'unité:

public interface IRepository
{
    Task<IEnumerable<T>> GetListAsync<T>(string storedProcedure, object template);

    Task<IEnumerable<T>> GetListAsync<T>(string sql, CommandType commandType, object template);
}

public interface ICRUDRepository<TEntity>
{
    Task<TEntity> GetByIdAsync(long Id);

    Task<int> AddAsync(TEntity entity);

    Task<int> UpdateAsync(TEntity entity);

    Task<int> DeleteAsync(long id);
}

public interface ITARRepository : IRepository, ICRUDRepository<TARTracker>
{
    Task<IEnumerable<TARTrackerDate>> GetTARTrackerApprovedDates(long tarTrackerId);
    Task<IEnumerable<TARTrackerDate>> MergeTARApprovalDateChanges(DataTable approvedDates);
}

Je pense que cela devrait correspondre. Je n'arrive pas à comprendre ce qui se passe. De l'aide?