Faking GetAsync call from test

Question

public Fixture()
{
      _server = new TestServer(new WebHostBuilder()    
         .UseStartup<Startup>()
           .ConfigureServices(services =>
           {
              services.AddScoped<ICarService, CarService>();
           }));

      Client = _server.CreateClient();
}

from tests I'm using this HttpClient to test my API.

using (var response = await _client.GetAsync($"/api/car/{id}"))
{
    //...         
}

The thing is that I want to fake the result of the GetAsync(int id) method in CarService class.

So I tried

var myCarObject = ... omitted for clarity
var myCarMockService = new Mock<ICarService>();
myCarMockService.Setup(x => x.GetAsync(It.IsAny<int>())).Returns(Task.FromResult(myCarObject));

I don't know is this right approach, but if it is how can I inject it into Fixture class so CarService can use it.

public class CarService: ICarService {
    private readonly CarDbContext _carDbContext;

    public CarService(CarDbContext carDbContext)
    {
        _carDbContext = carDbContext;
    }

    public async Task<Car> GetAsync(int id)
    {
        return await _carDbContext.Cars.FindAsync(id);
    }
}

Update:

private readonly ICarService _carService;

public CarController(ICarService carService)
{
    _carService = carService;
}

public async Task<IActionResult> Get([FromRoute] int id)
{
    var car = await _carService.GetAsync(id);
}

Update 2:

public class Startup
{
   public void ConfigureServices(IServiceCollection services)
   {
       services.AddDbContext<CarDbContext>(options => { options.UseSqlServer(Configuration.GetConnectionString("Db")); });
       services.AddTransient<ICarService, CarService>();
   }
}

public class CarService : ICarService
{
    private readonly CarDbContext _carDbContext;

    public ContactService(CarDbContext carDbContext)
    {
       _carDbContext= carDbContext;
    }
    public async Task<Owner> GetAsync(int ownerId)
    {
       var owner = await _carDbContext.Owners.FindAsync(ownerId);
       return owner.Car;            
    }
}

Update 3:

private readonly TestServer _server;
public Fixture()
{
    var dbContextOptions = new DbContextOptionsBuilder<CarDbContext>()
                    .UseInMemoryDatabase(Guid.NewGuid().ToString())
                    .Options;

    var mockContext = new Mock<CarDbContext>(dbContextOptions);
    var mockOwnerSet = new Mock<DbSet<Owner>>();
    var mockCarSet = new Mock<DbSet<Car>>();
    mockContext.Setup(m => m.Owners).Returns(mockOwnerSet.Object);
    mockContext.Setup(m => m.Cars).Returns(mockCarSet.Object);          

    var carService = new CarService(mockContext.Object);

    _server = new TestServer(new WebHostBuilder()
        .ConfigureAppConfiguration((context, conf) =>
        {
            conf.AddJsonFile(@Directory.GetCurrentDirectory() + "../appsettings.json");
        }).UseStartup<Startup>()
            .ConfigureServices(services =>
            {
                services.AddDbContext<CarDbContext>(options => options.UseInMemoryDatabase("Test"));
                services.AddScoped<ICarService>(_ => carService);
            })
        );

    Client = _server.CreateClient();    
}   

Answer 1

Configure the test server to use the mocked service

public Fixture() {

    Car myCarObject = //... omitted for brevity
    var myCarMockService = new Mock<ICarService>();
    myCarMockService
        .Setup(x => x.GetAsync(It.IsAny<int>()))
        .ReturnsAsync(myCarObject);

    _server = new TestServer(new WebHostBuilder()
        .UseStartup<Startup>()
        .ConfigureTestServices(services => {
            var serviceDescriptor = services.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(ICarService));
            if (serviceDescriptor != null) services.Remove(serviceDescriptor);
            services.AddTransient<ICarService>(_ => myCarMockService.Object); // <-- NOTE
        })
    );

    Client = _server.CreateClient();
}

That way when the call is made the mocked service will be injected as expected.