Test controller action that makes an external API call - asp.net-mvc

Question

I have an API controller with an action function. This function makes an external call for another API to get some data. this external call is made by simply creating a client with a URL. I want to create a test using WebApplicationFactory to test this action function.
I would like to know how to configure this external call. To say if the server calls this URL return this response.
May be it should be somewhere in overriding ConfigureWebHost to tell the server that if you call this URL (The external API url) return this response.
Here is the controller action I want to test.
namespace MyAppAPI.Controllers
{
public class MyController : ControllerBase
{
[HttpPost("MyAction")]
public async Task MyAction([FromBody] int inputParam)
{
var externalApiURL = "http://www.external.com?param=inputParam";
var client = new HttpClient();
var externalResponse = await client.GetAsync(externalApiURL);
//more work with the externalResponse
}
}
}
Here is the Test class I want to use
public class MyAppAPITests : IClassFixture<WebApplicationFactory<MyAppAPI.Startup>>
{
private readonly WebApplicationFactory<MyAppAPI.Startup> _factory;
public MyAppAPITests(WebApplicationFactory<MyAppAPI.Startup> factory)
{
_factory = factory;
}
[Fact]
public async Task Test_MyActionReturnsExpectedResponse()
{
//Arrange Code
//Act
//Here I would like to have something like this or a similar fashion
_factory.ConfigureReponseForURL("http://www.external.com?param=inputParam",
response => {
response.Response = "ExpectedResponse";
});
//Assert Code
}
}
The code in Test_MyActionReturnsExpectedResponse does not exist anywhere, it is just what I would like to have either by inheriting WebApplicationFactory or by configuring it. I would like to know how that can be achieved. i.e. configuring a response when an API controller makes an external call.
Thank you for your help.

Answer 1

The issue is that you have a hidden dependency, namely HttpClient. Because you're newing this up in your action, it's impossible to mock. Instead, you should be injecting this dependency into your controller. With ASP.NET Core 2.1+ that's possible with HttpClient thanks to IHttpClientFactory. However, out of the box, you cannot inject HttpClient directly into a controller, because controllers are not registered in the service collection. While you can change that, the recommended approach is to instead create a "service" class. This is actually better anyways as it abstract the knowledge of interacting with this API out of your controller entirely. Long and short, you should do something like:
public class ExternalApiService
{
private readonly HttpClient _httpClient;
public ExternalApiService(HttpClient httpClient)
{
_httpClient = httpClient;
}
public Task<ExternalReponseType> GetExternalResponseAsync(int inputParam) =>
_httpClient.GetAsync($"/endpoint?param={inputParam}");
}
Then, register this in ConfigureServices:
services.AddHttpClient<ExternalApiService>(c =>
{
c.BaseAddress = new Uri("http://www.external.com");
});
And finally, inject it into your controller:
public class MyController : ControllerBase
{
private readonly ExternalApiService _externalApi;
public MyController(ExternalApiService externalApi)
{
_externalApi = externalApi;
}
[HttpPost("MyAction")]
public async Task MyAction([FromBody] int inputParam)
{
var externalResponse = await _externalApi.GetExternalResponseAsync(inputParam);
//more work with the externalResponse
}
}
Now, the logic for working with this API is abstracted from your controller and you have a dependency you can easily mock. Since you're wanting to do integration testing, you'll need to sub in a different service implementation when testing. For that, I'd actually do a little further abstraction. First, create an interface for the ExternalApiService and make the service implement that. Then, in your test project you can create an alternate implementation that bypasses HttpClient entirely and just returns pre-made responses. Then, while not strictly necessary, I'd create an IServiceCollection extension to abstract the AddHttpClient call, allowing you to reuse this logic without repeating yourself:
public static class IServiceCollectionExtensions
{
public static IServiceCollection AddExternalApiService<TImplementation>(this IServiceCollection services, string baseAddress)
where TImplementation : class, IExternalApiService
{
services.AddHttpClient<IExternalApiService, TImplementation>(c =>
{
c.BaseAddress = new Uri(baseAddress)
});
return services;
}
}
Which you would then use like:
services.AddExternalApiService<ExternalApiService>("http://www.external.com");
The base address could (and probably should) be provided via config, for an extra layer of abstraction/testability. Finally, you should be use a TestStartup with WebApplicationFactory. It makes it far easier to switch out services and other implementations without rewriting all your ConfigureServices logic in Startup, which of course adds variables to your test: e.g. is it not working because I forgot to register something the same way as in my real Startup?
Simply add some virtual methods to your Startup class and then use these for things like adding your databases, and here, adding your service:
public class Startup
{
...
public void ConfigureServices(IServiceCollection services)
{
...
AddExternalApiService(services);
}
protected virtual void AddExternalApiService(IServiceCollection services)
{
services.AddExternalApiService<ExternalApiService>("http://www.external.com");
}
}
Then, in your test project, you can derive from Startup and override this and similar methods:
public class TestStartup : MyAppAPI.Startup
{
protected override void AddExternalApiService(IServiceCollection services)
{
// sub in your test `IExternalApiService` implementation
services.AddExternalApiService<TestExternalApiService>("http://www.external.com");
}
}
Finally, when getting your test client:
var client = _factory.WithWebHostBuilder(b => b.UseStartup<TestStartup>()).CreateClient();
The actual WebApplicationFactory still uses MyAppAPI.Startup, since that generic type param corresponds to the app entry point, not actually what Startup class is being used.

Answer 2

I think best way - i to use interfaces and MOCK's. Implement interface by inheritance of HttpClient and at the test mock this interface:
public interface IHttpClientMockable
{
Task<string> GetStringAsync(string requestUri);
Task<string> GetStringAsync(Uri requestUri);
Task<byte[]> GetByteArrayAsync(string requestUri);
Task<byte[]> GetByteArrayAsync(Uri requestUri);
Task<Stream> GetStreamAsync(string requestUri);
Task<Stream> GetStreamAsync(Uri requestUri);
Task<HttpResponseMessage> GetAsync(string requestUri);
Task<HttpResponseMessage> GetAsync(Uri requestUri);
Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption);
Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption);
Task<HttpResponseMessage> GetAsync(string requestUri, CancellationToken cancellationToken);
Task<HttpResponseMessage> GetAsync(Uri requestUri, CancellationToken cancellationToken);
Task<HttpResponseMessage> GetAsync(string requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken);
Task<HttpResponseMessage> GetAsync(Uri requestUri, HttpCompletionOption completionOption, CancellationToken cancellationToken);
Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content);
Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content);
Task<HttpResponseMessage> PostAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
Task<HttpResponseMessage> PostAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content);
Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content);
Task<HttpResponseMessage> PutAsync(string requestUri, HttpContent content, CancellationToken cancellationToken);
Task<HttpResponseMessage> PutAsync(Uri requestUri, HttpContent content, CancellationToken cancellationToken);
Task<HttpResponseMessage> DeleteAsync(string requestUri);
Task<HttpResponseMessage> DeleteAsync(Uri requestUri);
Task<HttpResponseMessage> DeleteAsync(string requestUri, CancellationToken cancellationToken);
Task<HttpResponseMessage> DeleteAsync(Uri requestUri, CancellationToken cancellationToken);
Task<HttpResponseMessage> SendAsync(HttpRequestMessage request);
Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);
Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption);
Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken);
void CancelPendingRequests();
HttpRequestHeaders DefaultRequestHeaders { get; }
Uri BaseAddress { get; set; }
TimeSpan Timeout { get; set; }
long MaxResponseContentBufferSize { get; set; }
void Dispose();
}
public class HttpClientMockable: HttpClient, IHttpClientMockable
{
}