Microsoft.AspNetCore.App
Microsoft.AspNetCore.TestHost

 [Route("api/[controller]")]
 [ApiController]
 public class ValuesController : ControllerBase
 {
 private IConfiguration configuration;
 public ValuesController(IConfiguration configuration)
 {
  this.configuration = configuration;
 }

 [HttpGet("{id}")]
 public ActionResult<int> Get(int id)
 {
  var result= id + this.configuration.GetValue<int>("max");

  return result;
 }
 }

Microsoft.AspNetCore.TestHost.TestServer

 public class TestServer : IServer
 {
 private IWebHost _hostInstance;
 private bool _disposed = false;
 private IHttpApplication<Context> _application;

 public TestServer(): this(new FeatureCollection())
 {
 }

 public TestServer(IFeatureCollection featureCollection)
 {
  Features = featureCollection "http://localhost/");

 public IWebHost Host
 {
  get
  {
  return _hostInstance
   "The TestServer constructor was not called with a IWebHostBuilder so IWebHost is not available.");
  }
 }

 public IFeatureCollection Features { get; }

 private IHttpApplication<Context> Application
 {
  get => _application "The server has not been started or no web application was configured.");
 }

 public HttpMessageHandler CreateHandler()
 {
  var pathBase = BaseAddress == null "/"))
  {
   pathBase = new PathString(pathBase.Value.Substring(0, pathBase.Value.Length - 1));
  }
  request.PathBase = pathBase;
  });
  builder.Configure(configureContext);
  return await builder.SendAsync(cancellationToken).ConfigureAwait(false);
 }

 public void Dispose()
 {
  if (!_disposed)
  {
  _disposed = true;
  _hostInstance.Dispose();
  }
 }

 Task IServer.StartAsync<TContext>(IHttpApplication<TContext> application, CancellationToken cancellationToken)
 {
  _application = new ApplicationWrapper<Context>((IHttpApplication<Context>)application, () =>
  {
  if (_disposed)
  {
   throw new ObjectDisposedException(GetType().FullName);
  }
  });

  return Task.CompletedTask;
 }

 Task IServer.StopAsync(CancellationToken cancellationToken)
 {
  return Task.CompletedTask;
 }

 private class ApplicationWrapper<TContext> : IHttpApplication<TContext>
 {
  private readonly IHttpApplication<TContext> _application;
  private readonly Action _preProcessRequestAsync;

  public ApplicationWrapper(IHttpApplication<TContext> application, Action preProcessRequestAsync)
  {
  _application = application;
  _preProcessRequestAsync = preProcessRequestAsync;
  }

  public TContext CreateContext(IFeatureCollection contextFeatures)
  {
  return _application.CreateContext(contextFeatures);
  }

  public void DisposeContext(TContext context, Exception exception)
  {
  _application.DisposeContext(context, exception);
  }

  public Task ProcessRequestAsync(TContext context)
  {
  _preProcessRequestAsync();
  return _application.ProcessRequestAsync(context);
  }
 }
 }

 public TestServer(IWebHostBuilder builder)
  : this(builder, new FeatureCollection())
 {
 }

 public class ValuesUnitTest
 {
 private TestServer testServer;
 private HttpClient httpCLient;

 public ValuesUnitTest()
 {
  testServer = new TestServer(new WebHostBuilder().UseStartup<Ron.TestDemo.Startup>());
  httpCLient = testServer.CreateClient();
 }

 [Fact]
 public async void GetTest()
 {
  var data = await httpCLient.GetAsync("/api/values/100");
  var result = await data.Content.ReadAsStringAsync();

  Assert.Equal("300", result);
 }
 }

WebHost.CreateDefaultBuilder

 public class Startup
 {
 public Startup(IConfiguration configuration, IHostingEnvironment env)
 {
  this.Configuration = new ConfigurationBuilder()
  .AddJsonFile("appsettings.json")
  .AddEnvironmentVariables()
  .SetBasePath(env.ContentRootPath)
  .Build();
 }

 public IConfiguration Configuration { get; }

 // This method gets called by the runtime. Use this method to add services to the container.
 public void ConfigureServices(IServiceCollection services)
 {
  services.AddSingleton<IConfiguration>(this.Configuration);
  services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
 }
 }