private async Task<List<ApplicationHealthModel>> CreateApplicationHealthModelTasksAsync(IList<Models.PathModel> paths)
{
var bearerToken = User.Identity.IsAuthenticated ? await bearerTokenRetriever.GetToken(HttpContext).ConfigureAwait(false) : null;
var applicationHealthModels = new List<ApplicationHealthModel>();
foreach (var path in paths)
{
logger.LogInformation($"{nameof(Action)}: Getting child Health for: {path.Path}");
var applicationBaseUrl = await GetPathBaseUrlFromBodyRegionAsync(path.Path).ConfigureAwait(false);
var applicationHealthModel = new ApplicationHealthModel
{
Path = path.Path,
BearerToken = bearerToken,
HealthUrl = $"{applicationBaseUrl}/health",
};
applicationHealthModel.RetrievalTask = applicationHealthService.GetAsync(applicationHealthModel);
applicationHealthModels.Add(applicationHealthModel);
}
return applicationHealthModels;
}
public async Task <IEnumerable <HealthItemModel> > GetAsync(ApplicationHealthModel model)
{
if (model == null)
{
return(null);
}
var responseTask = await CallHttpClientJsonAsync(model).ConfigureAwait(false);
return(responseTask);
}
public async Task GetAsyncReturnsHealthTextWhenApiReturnsHealthText()
{
// Arrange
var expectedResponse = new List <HealthItemModel>
{
new HealthItemModel
{
Service = "A service 1",
Message = "A message 1",
},
new HealthItemModel
{
Service = "A service 2",
Message = "A message 2",
},
};
string expectedResponseString = JsonConvert.SerializeObject(expectedResponse);
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(expectedResponseString),
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var healthService = new ApplicationHealthService(httpClient, logger);
var model = new ApplicationHealthModel {
BearerToken = "SomeBearerToken"
};
// Act
var result = await healthService.GetAsync(model);
// Assert
string resultString = JsonConvert.SerializeObject(result);
Assert.Equal(expectedResponseString, resultString);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
private async Task <IEnumerable <HealthItemModel> > CallHttpClientJsonAsync(ApplicationHealthModel model)
{
logger.LogInformation($"{nameof(CallHttpClientJsonAsync)}: Loading health data from {model.HealthUrl}");
var request = new HttpRequestMessage(HttpMethod.Get, model.HealthUrl);
if (!string.IsNullOrWhiteSpace(model.BearerToken))
{
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", model.BearerToken);
}
request.Headers.Accept.Clear();
request.Headers.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
var response = await httpClient.SendAsync(request).ConfigureAwait(false);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var responseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var result = JsonSerializer.Deserialize <List <HealthItemModel> >(responseString);
logger.LogInformation($"{nameof(CallHttpClientJsonAsync)}: Loaded health data from {model.HealthUrl}");
return(result);
}
else
{
logger.LogError($"{nameof(CallHttpClientJsonAsync)}: Error loading health data from {model.HealthUrl}: {response.StatusCode}");
var result = new List <HealthItemModel>
{
new HealthItemModel
{
Service = model.Path,
Message = $"No health response from {model.HealthUrl} app",
},
};
return(result);
}
}
