public async Task PatchAsyncReturnsExceptionForBadStatus()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.Forbidden;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult, Content = new StringContent("bad Patch")
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = segmentClientOptions.BaseAddress
};
var httpClientService = new HttpClientService(segmentClientOptions, httpClient, logService, correlationIdProvider);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var exceptionResult = await Assert.ThrowsAsync <HttpRequestException>(async() => await httpClientService.PatchAsync(A.Fake <PatchLinksModel>(), "endpoint").ConfigureAwait(false)).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal($"Response status code does not indicate success: {(int)expectedResult} ({expectedResult}).", exceptionResult.Message);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task PutAsyncReturnsStatusWhenHttpResponseIsNotFound()
{
// Arrange
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.NotFound, Content = new StringContent("Unsuccessful content")
};
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 httpClientService = new HttpClientService(options, httpClient, logger);
// Act
var result = await httpClientService.PutAsync(GetSegmentModel()).ConfigureAwait(false);
// Assert
Assert.Equal(HttpStatusCode.NotFound, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task ApiServiceDeleteReturnsNotFoundStatusCode()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.NotFound;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
var apiService = new ApiService(logger);
var url = new Uri("https://www.somewhere.com", UriKind.Absolute);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await apiService.DeleteAsync(httpClient, url).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task PostAsyncReturnsOKStatusCodeWhenHttpResponseIsSuccessful()
{
// Arrange
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.OK
};
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 httpClientService = new HttpClientService(options, httpClient, logService, correlationIdProvider);
// Act
var result = await httpClientService.PostAsync(GetSegmentModel()).ConfigureAwait(false);
// Assert
Assert.Equal(HttpStatusCode.OK, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task SubscriptionRegistrationBackgroundServiceCorrectWebhookSettingReturnsDownstreamError()
{
//Arrange
A.CallTo(() => configuration["Configuration:ApplicationName"]).Returns("test-app");
A.CallTo(() => settings.CurrentValue).Returns(new SubscriptionSettings {
Endpoint = new Uri("https://somewebhookreceiver.com/receive"), SubscriptionServiceEndpoint = new Uri("https://somewheretosubscribeto.com")
});
var httpResponse = new HttpResponseMessage {
StatusCode = System.Net.HttpStatusCode.InternalServerError, Content = new StringContent("An error", Encoding.UTF8)
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
A.CallTo(() => httpClientFactory.CreateClient(A <string> .Ignored)).Returns(httpClient);
var serviceToTest = new SubscriptionRegistrationService(settings, httpClientFactory, logger);
//Act
//Assert
await Assert.ThrowsAsync <HttpRequestException>(async() => await serviceToTest.RegisterSubscription("a-test-subscriber").ConfigureAwait(false)).ConfigureAwait(false);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
httpResponse.Dispose();
fakeHttpMessageHandler.Dispose();
httpClient.Dispose();
}
public async Task ApiServiceGetReturnsOkStatusCodeForValidUrl()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.OK;
const string expectedResponse = "Expected response string";
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult, Content = new StringContent(expectedResponse)
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
var apiService = new ApiService(logger);
var url = new Uri("https://www.somewhere.com", UriKind.Absolute);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await apiService.GetAsync(httpClient, url, MediaTypeNames.Application.Json).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResponse, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public void GetCdnAssetFileAndVersionReturnsPathWithHashCodeWhenValidResponseFromCDN()
{
const string testHeader = "test";
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new MultipartContent(),
};
httpResponse.Content.Headers.Add("content-md5", testHeader);
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
var assetLocationAndVersionService = new AssetLocationAndVersionService(httpClient, asyncHelper, webHostEnvironment, logger, fileInfoHelper);
var result = assetLocationAndVersionService.GetCdnAssetFileAndVersion(TestCDNLocation);
var expectedResult = $"{TestCDNLocation}?{testHeader}";
Assert.Equal(expectedResult, result);
httpResponse.Dispose();
fakeHttpMessageHandler.Dispose();
httpClient.Dispose();
}
public void GetCdnAssetFileAndVersionReturnsPathWithCurrentDateWhenNoValidResponseFromCDN()
{
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.BadGateway,
Content = new MultipartContent(),
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
var assetLocationAndVersionService = new AssetLocationAndVersionService(httpClient, asyncHelper, webHostEnvironment, logger, fileInfoHelper);
var result = assetLocationAndVersionService.GetCdnAssetFileAndVersion(TestCDNLocation);
var expectedFormattedDate = DateTime.Now.ToString("yyyyMMddHH", CultureInfo.InvariantCulture);
var expectedResult = $"{TestCDNLocation}?{expectedFormattedDate}";
Assert.Equal(expectedResult, result);
httpResponse.Dispose();
fakeHttpMessageHandler.Dispose();
httpClient.Dispose();
}
public async Task GetLocationsReturnsLocations()
{
//Setup
var expectedResponse = GetTestResponse();
var httpResponse = new HttpResponseMessage
{
Content = new StringContent(JsonConvert.SerializeObject(expectedResponse)),
StatusCode = HttpStatusCode.Accepted,
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
httpClient.BaseAddress = new System.Uri("https://dummy.com");
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var nationalStatisticsLocationService = new NationalStatisticsLocationService(fakeLogger, httpClient);
//Act
var actual = await nationalStatisticsLocationService.GetLocationsAsync().ConfigureAwait(false);
//Assert
actual.Should().BeEquivalentTo(expectedResponse.Locations);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task PutAsyncReturnsExceptionWhenHttpResponseIsNotSuccessful()
{
// Arrange
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.InternalServerError, Content = new StringContent("Unsuccessful content")
};
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 httpClientService = new HttpClientService(options, httpClient, logService, correlationIdProvider);
// Act
await Assert.ThrowsAsync <HttpRequestException>(async() => await httpClientService.PutAsync(GetSegmentModel()).ConfigureAwait(false)).ConfigureAwait(false);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task GetContentWhenRegionReturnsRedirectResponseThenFollowRedirect()
{
var redirectHttpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.Redirect,
Content = new StringContent(DummyChildAppContent),
};
redirectHttpResponse.Headers.Location = new Uri("http://SomeLocation");
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(redirectHttpResponse);
var fakeRedirectHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var redirectHttpClient = new HttpClient(fakeRedirectHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeRegionBaseAddress"),
};
var model = new RegionModel
{
IsHealthy = true,
};
var service = new ContentRetriever(redirectHttpClient, logger, regionService, httpResponseMessageHandler);
await service.GetContent("someUrl", model, true, "baseUrl").ConfigureAwait(false);
A.CallTo(() => httpResponseMessageHandler.Process(null)).MustHaveHappened();
fakeRedirectHttpMessageHandler.Dispose();
redirectHttpResponse.Dispose();
redirectHttpClient.Dispose();
}
public async Task PatchAsyncReturnsNotFoundStatusCodeForExistingId()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.NotFound;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = segmentClientOptions.BaseAddress
};
var httpClientService = new HttpClientService(segmentClientOptions, httpClient, logService, correlationIdProvider);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await httpClientService.PatchAsync(A.Fake <PatchLinksModel>(), "endpoint").ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task PostFullJobProfileAsyncReturnsOkStatusCodeForExistingId()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.OK;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = coreClientOptions.BaseAddress
};
var httpClientService = new HttpClientService(coreClientOptions, httpClient, logService, correlationIdProvider);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await httpClientService.PostAsync(A.Fake <CurrentOpportunitiesSegmentModel>()).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task ApiServiceGetReturnsNoContentStatusCode()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.NoContent;
string expectedResponse = string.Empty;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult, Content = new StringContent(expectedResponse)
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await apiService.GetAsync(httpClient, dummyUrl, MediaTypeNames.Application.Json).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Null(result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task RefreshApprenticeshipsReturnsNullWhenError()
{
// arrange
const HttpStatusCode expectedStatusCode = HttpStatusCode.BadRequest;
var documentId = Guid.NewGuid();
var httpResponse = new HttpResponseMessage {
StatusCode = expectedStatusCode
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
using (var httpClient = new HttpClient(fakeHttpMessageHandler))
{
var refreshService = new RefreshService(httpClient, fakeLogger, fakeRefreshClientOptions);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await refreshService.RefreshApprenticeshipsAsync(documentId).ConfigureAwait(false);
// assert
Assert.Equal(result, expectedStatusCode);
}
httpResponse.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task DataLoadServiceGetJobProfileByIdReturnsEmptyResponse()
{
// arrange
var apiResponse = File.ReadAllText(Directory.GetCurrentDirectory() + "/DataLoadServiceTests/Files/DataLoadService_GetAll_JobProfile_Response.json");
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.InternalServerError, Content = new StringContent(apiResponse)
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://somebaseaddress")
};
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var dataLoadService = new DataLoadService <ServiceTaxonomyApiClientOptions>(httpClient, A.Fake <ServiceTaxonomyApiClientOptions>());
// act
var result = await dataLoadService.GetByIdAsync <JobProfile>("JobProfile", Guid.NewGuid()).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Null(result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task CourseGetAsyncReturnsHttpRequestExceptionWhenApiReturnsNotSuccessful()
{
// Arrange
var courseGetRequest = new CourseGetRequest {
CourseId = courseId, RunId = courseRunId
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, Content = new StringContent("{}")
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
// Act
await Assert.ThrowsAsync <HttpRequestException>(async() => await findACourseClient.CourseGetAsync(courseGetRequest).ConfigureAwait(false)).ConfigureAwait(false);
// Assert
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task RefreshApprenticeshipsReturnsNotFound()
{
// arrange
var documentId = Guid.NewGuid();
const HttpStatusCode expectedStatusCode = HttpStatusCode.NotFound;
var feedRefreshResponseModel = new FeedRefreshResponseModel()
{
NumberPulled = 0, RequestErrorMessage = "No results"
};
var httpResponse = new HttpResponseMessage {
StatusCode = expectedStatusCode, Content = new StringContent(JsonConvert.SerializeObject(feedRefreshResponseModel))
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
using (var httpClient = new HttpClient(fakeHttpMessageHandler))
{
var refreshService = new RefreshService(httpClient, fakeLogger, fakeRefreshClientOptions);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await refreshService.RefreshApprenticeshipsAsync(documentId).ConfigureAwait(false);
// assert
Assert.Equal(result, expectedStatusCode);
}
httpResponse.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task GetAsyncReturnsRobotTextWhenApiReturnsRobotText()
{
const string ExpectedResponseText = "SomeResponseText";
var httpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(ExpectedResponseText),
};
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://SomeDummyCDNUrl")
};
var robotService = new ApplicationRobotService(httpClient);
var model = new ApplicationRobotModel {
BearerToken = "SomeBearerToken"
};
var result = await robotService.GetAsync(model);
Assert.Equal(ExpectedResponseText, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task CourseSearchAsyncReturnsBlankResultsWhenApiReturnsBadRequest()
{
// Arrange
var courseSearchRequest = new CourseSearchRequest {
SubjectKeyword = "Somekeyword"
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, Content = new StringContent("{}")
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
var result = await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.Empty(result.Results);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task GetSimpleListReturnsNullWhenError()
{
// arrange
const HttpStatusCode expectedStatusCode = HttpStatusCode.NotFound;
IEnumerable <SimpleJobProfileModel> expectedResults = null;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedStatusCode, Content = new StringContent(JsonConvert.SerializeObject(expectedResults))
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
using (var httpClient = new HttpClient(fakeHttpMessageHandler))
{
var refreshService = new RefreshService(httpClient, fakeLogger, fakeRefreshClientOptions);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var results = await refreshService.GetListAsync().ConfigureAwait(false);
// assert
Assert.Equal(expectedResults, results);
}
httpResponse.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task GetContentWhenRegionReturnsRedirectResponseThenThrowRedirectException()
{
var redirectHttpResponse = new HttpResponseMessage
{
StatusCode = HttpStatusCode.Redirect,
Content = new StringContent(DummyChildAppContent),
};
redirectHttpResponse.Headers.Location = new Uri("http://SomeLocation");
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(redirectHttpResponse);
var fakeRedirectHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var redirectHttpClient = new HttpClient(fakeRedirectHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeRegionBaseAddress"),
};
var model = new RegionModel
{
IsHealthy = true,
};
var service = new ContentRetriever(redirectHttpClient, logger, appRegistryDataService, httpResponseMessageHandler, markupMessages);
await Assert.ThrowsAnyAsync <RedirectException>(async() => await service.GetContent("http://someUrl", "path", model, false, "http://baseUrl").ConfigureAwait(false)).ConfigureAwait(false);
fakeRedirectHttpMessageHandler.Dispose();
redirectHttpResponse.Dispose();
redirectHttpClient.Dispose();
}
public async Task DeleteAsyncReturnsNotFoundStatusCodeForExistingId()
{
// arrange
const HttpStatusCode expectedResult = HttpStatusCode.NotFound;
var httpResponse = new HttpResponseMessage {
StatusCode = expectedResult
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = contentPageClientOptions.BaseAddress
};
var httpClientService = new HttpClientService(contentPageClientOptions, httpClient, logger);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
// act
var result = await httpClientService.DeleteAsync(Guid.NewGuid()).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Equal(expectedResult, result);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task Given_Location_And_Path_When_SetSchemaAsync_Invoked_Then_It_Should_Return_Result(string schema, string location, string path, HttpStatusCode statusCode)
{
var content = new StringContent(schema);
var response = new HttpResponseMessage(statusCode)
{
Content = content
};
var options = new HttpMessageOptions()
{
HttpResponseMessage = response
};
var handler = new FakeHttpMessageHandler(options);
var httpClient = new HttpClient(handler);
var instance = new HttpSchemaSink()
.WithBaseLocation(location)
.WithHttpClient(httpClient);
var result = await instance.SetSchemaAsync(schema, path).ConfigureAwait(false);
result.Should().BeTrue();
content.Dispose();
handler.Dispose();
httpClient.Dispose();
}
public async Task PostContentWhenResponseIsStatusFoundThrowRedirectException()
{
var model = new RegionModel
{
IsHealthy = true,
RegionEndpoint = "SomeRegionEndpoint",
PageRegion = PageRegion.Body,
};
var httpResponseMessage = new HttpResponseMessage
{
StatusCode = HttpStatusCode.Found,
Content = new StringContent(DummyChildAppContent),
};
httpResponseMessage.Headers.Location = new Uri("http://SomeLocation");
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponseMessage);
var fakeRedirectHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var postHttpClient = new HttpClient(fakeRedirectHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeRegionBaseAddress"),
};
var service = new ContentRetriever(postHttpClient, logger, regionService, httpResponseMessageHandler);
await Assert.ThrowsAnyAsync <RedirectException>(async() => await service.PostContent("http://someUrl", model, defaultFormPostParams, "http://baseUrl").ConfigureAwait(false)).ConfigureAwait(false);
httpResponseMessage.Dispose();
fakeRedirectHttpMessageHandler.Dispose();
postHttpClient.Dispose();
}
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();
}
public async Task CourseSearchAsyncReturnsResponseObjectWhenApiCallIsSuccessful()
{
// Arrange
var courseSearchRequest = new CourseSearchRequest {
SubjectKeyword = "Somekeyword"
};
var expectedResponse = new CourseSearchResponse
{
Results = new List <Result>
{
new Result
{
CourseId = courseId,
CourseRunId = courseRunId,
CourseName = "CourseName",
},
},
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.OK, Content = new StringContent(JsonConvert.SerializeObject(expectedResponse))
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
// Act
var result = await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.Equal(expectedResponse.Results.FirstOrDefault()?.CourseName, result.Results?.FirstOrDefault()?.CourseName);
Assert.Equal(expectedResponse.Results?.FirstOrDefault()?.CourseRunId, result.Results?.FirstOrDefault()?.CourseRunId);
Assert.Equal(expectedResponse.Results?.FirstOrDefault()?.CourseId, result.Results?.FirstOrDefault()?.CourseId);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task TLevelGetAsyncReturnsResponseObjectWhenApiCallIsSuccessful()
{
// Arrange
var expectedResponse = new TLevelDetailResponse
{
TLevelId = tLevelId,
Qualification = new TLevelQualification()
{
TLevelName = "testTLevel"
},
Provider = new TLevelProvider()
{
ProviderName = "testProvider"
},
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.OK, Content = new StringContent(JsonConvert.SerializeObject(expectedResponse))
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
// Act
var result = await findACourseClient.TLevelGetAsync(tLevelId.ToString()).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.Equal(expectedResponse.Qualification.TLevelName, result.Qualification.TLevelName);
Assert.Equal(expectedResponse.Provider.ProviderName, result.Provider.ProviderName);
Assert.Equal(expectedResponse.TLevelId, result.TLevelId);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task ApiServiceGetReturnsExceptionResult()
{
// arrange
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler);
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Throws(new ArgumentException("fake exception"));
// act
var result = await apiService.GetAsync(httpClient, dummyUrl, MediaTypeNames.Application.Json).ConfigureAwait(false);
// assert
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).MustHaveHappenedOnceExactly();
Assert.Null(result);
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public void Given_Schema_And_Path_And_ErrorResponse_When_SetSchemaAsync_Invoked_Then_It_Should_Throw_Exception(string schema, string path, HttpStatusCode statusCode)
{
var response = new HttpResponseMessage(statusCode);
var options = new HttpMessageOptions()
{
HttpResponseMessage = response
};
var handler = new FakeHttpMessageHandler(options);
var httpClient = new HttpClient(handler);
var instance = new HttpSchemaSink()
.WithHttpClient(httpClient);
Func <Task> func = async() => await instance.SetSchemaAsync(schema, path).ConfigureAwait(false);
func.Should().Throw <HttpRequestException>();
handler.Dispose();
httpClient.Dispose();
}
