It's pretty common practice in .NET Core to take a dependency on HttpClient in your constructor and using the built-in DI container extension to register this. When it comes to unit testing it can always be a bit fiddly when you depend on a concrete class rather than an interface. After solving this problem several times when it comes to HttpClient based unit tests I've create a simple TestHttpClient and TestHttpClientBuilder to simplify the process:
public class TestHttpClientBuilder
{
	private readonly HttpResponseMessage _stubHttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK);

	public TestHttpClientBuilder WithStatusCode(HttpStatusCode statusCode)
	{
		_stubHttpResponseMessage.StatusCode = statusCode;
		return this;
	}

	public TestHttpClientBuilder WithJsonContent<T>(T expectedResponseObject)
	{
		_stubHttpResponseMessage.Content = new StringContent(JsonConvert.SerializeObject(expectedResponseObject), Encoding.UTF8, "application/json");
		return this;
	}

	public TestHttpClient Build()
	{
		return new TestHttpClient(
			new FakeHttpMessageHandler(_stubHttpResponseMessage));
	}

	public class TestHttpClient : HttpClient
	{
		private readonly FakeHttpMessageHandler _httpMessageHandler;

		internal TestHttpClient(FakeHttpMessageHandler httpMessageHandler) : base(httpMessageHandler)
		{
			_httpMessageHandler = httpMessageHandler;
			BaseAddress = new Uri("http://localhost.com");
		}

		public IReadOnlyList<HttpRequestMessage> CapturedRequests => _httpMessageHandler.CapturedRequests;
	}

	internal class FakeHttpMessageHandler : HttpMessageHandler
	{
		private readonly HttpResponseMessage _response;
		private readonly List<HttpRequestMessage> _capturedRequests = new List<HttpRequestMessage>();

		public FakeHttpMessageHandler(HttpResponseMessage response)
		{
			_response = response;
		}

		public IReadOnlyList<HttpRequestMessage> CapturedRequests => _capturedRequests;

		protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
						CancellationToken cancellationToken)
		{
			_capturedRequests.Add(request);

			return Task.FromResult(_response);
		}
	}
}
Given this code is available to your unit tests, you can now use the builder when instantiating the SUT and use the builder methods to configure the possible responses and/or inspect the captured requests to test your outbound calls. e.g.
public class UnitTestClass
{
	private TestHttpClientBuilder _testHttpClientBuilder;
	private Lazy<TestHttpClientBuilder.TestHttpClient> _testHttpClient;

	public void SetUp()
	{
		_testHttpClientBuilder = new TestHttpClientBuilder()
			.WithStatusCode(HttpStatusCode.OK)
			.WithJsonContent(new MyDataType()); // use AutoFixture, test data builder etc. to create a default response

		_testHttpClient = new Lazy<TestHttpClientBuilder.TestHttpClient>(() => _testHttpClientBuilder.Build());
	}

	// Now create tests on the SUT using "_testHttpClient.Value" for the HttpClient ctor argument.
	
	// Make assertions based on changing the response status code / content, or by inspecting "_testHttpClient.Value.CapturedRequests"
}