/// <summary>
/// Arranges the <see cref="HttpClient"/> instance.
/// </summary>
/// <param name="statusCode"><see cref="HttpStatusCode"/> value.</param>
/// <param name="phrase">Message related to the <see cref="HttpStatusCode"/> value.</param>
/// <param name="payload">Response payload.</param>
/// <returns>Returns the <see cref="HttpClient"/> instance.</returns>
public HttpClient ArrangeHttpClient(HttpStatusCode?statusCode = null, string phrase = null, object payload = null)
{
statusCode = statusCode.GetValueOrDefault(this.Fixture.Create <HttpStatusCode>());
phrase = phrase ?? this.Fixture.Create <string>();
var content = payload == null
? (StringContent)null
: new StringContent(JsonConvert.SerializeObject(payload), Encoding.UTF8, "application/json");
var res = this.Fixture.Build <HttpResponseMessage>()
.With(p => p.StatusCode, statusCode.Value)
.With(p => p.ReasonPhrase, phrase)
.With(p => p.Content, content)
.Create();
var messageOptions = new HttpMessageOptions()
{
HttpResponseMessage = res
};
var options = new[] { messageOptions };
var handler = new FakeHttpMessageHandler(options);
var client = new HttpClient(handler);
return(client);
}
/// <summary>
/// Creates a new instance of the <see cref="IGitHubService"/> class.
/// </summary>
/// <param name="res"><see cref="HttpResponseMessage"/> instance.</param>
/// <returns>Returns the <see cref="IGitHubService"/> instance.</returns>
public IGitHubService CreateInstance(HttpResponseMessage res)
{
var github = new Mock <GitHubSettings>();
github.SetupGet(p => p.ApiBaseUri).Returns("http://localhost");
github.SetupGet(p => p.RepositoryContentUri).Returns("repos/{0}/{1}/contents");
github.SetupGet(p => p.AzureUsername).Returns("arm");
github.SetupGet(p => p.AzureQuickstartTemplatesRepository).Returns("templates");
var settings = new Mock <IFunctionAppSettings>();
settings.SetupGet(p => p.GitHub).Returns(github.Object);
var messageOptions = new HttpMessageOptions()
{
HttpResponseMessage = res
};
var options = new[] { messageOptions };
var handler = new FakeHttpMessageHandler(options);
var client = new HttpClient(handler);
var service = new GitHubService(settings.Object, client);
return(service);
}
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 GivenAPutRequest_PutAsync_ReturnsAFakeResponse(HttpContent content)
{
// Arrange.
var requestUri = new Uri("http://www.something.com/some/website");
var options = new HttpMessageOptions
{
HttpMethod = HttpMethod.Put,
RequestUri = requestUri,
HttpContent = content,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.NoContent)
};
var messageHandler = new FakeHttpMessageHandler(options);
HttpResponseMessage message;
using (var httpClient = new System.Net.Http.HttpClient(messageHandler))
{
// Act.
message = await httpClient.PutAsync(requestUri, content);
}
// Assert.
message.StatusCode.ShouldBe(HttpStatusCode.NoContent);
}
public async Task Given_HttpClient_When_SendMessageAsync_Invoked_Then_It_Should_Return_Result(string message, HttpStatusCode statusCode, int expected)
{
var options = new Mock <Options>();
options.SetupGet(p => p.Title).Returns("hello world");
options.SetupGet(p => p.WebhookUri).Returns("https://localhost");
var content = new StringContent(message);
var response = new HttpResponseMessage(statusCode)
{
Content = content
};
var messageOptions = new HttpMessageOptions()
{
HttpResponseMessage = response
};
var httpHandler = new FakeHttpMessageHandler(messageOptions);
var httpClient = new HttpClient(httpHandler);
var handler = new MessageHandler();
handler.BuildMessage(options.Object, settings);
var result = await handler.SendMessageAsync(httpClient).ConfigureAwait(false);
result.Should().Be(expected);
}
public async Task HandleAsync_raises_event_when_completed()
{
// ARRANGE
var text = string.Format(this.HtmlFormat, _fixture.Create <string>());
var httpOption = new HttpMessageOptions
{
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(text)
}
};
var options = _fixture.Create <TranslateOptions>();
var translation = _fixture.Create <TranslateTextResponse>();
_mockTranslate.Setup(e => e.TranslateTextAsync(It.IsAny <TranslateTextRequest>(), CancellationToken.None))
.ReturnsAsync(translation);
_mockS3.Setup(s => s.PutObjectAsync(It.IsAny <PutObjectRequest>(), CancellationToken.None));
var sut = CreateSystemUnderTest(options, httpOption);
var context = _fixture.Create <NybusCommandContext <TranslateEducationCommand> >();
// ACT
await sut.HandleAsync(_mockDispatcher.Object, context);
// ASSERT
_mockDispatcher.Verify(e => e.RaiseEventAsync(It.IsAny <EducationTranslatedEvent>(), It.IsAny <IDictionary <string, string> >()));
}
public void GivenAnInvalidHttpVerb_GetAsync_ThrowsAnException()
{
// Arrange.
const string requestUrl = "http://www.something.com/some/website";
const string responseData = "Delete me plz";
var messageResponse = FakeHttpMessageHandler.GetStringHttpResponseMessage(responseData);
var options = new HttpMessageOptions
{
RequestUri = requestUrl,
HttpMethod = HttpMethod.Delete,
HttpResponseMessage = messageResponse
};
var messageHandler = new FakeHttpMessageHandler(options);
Exception exception;
using (var httpClient = HttpClientFactory.GetHttpClient(messageHandler))
{
// Act.
exception = Should.Throw <InvalidOperationException>(() => httpClient.GetAsync(requestUrl));
}
// Assert.
exception.Message.ShouldBe(
$"No HttpResponseMessage found for the Request Uri: {requestUrl}. Please provide one in the FakeHttpMessageHandler constructor Or use a '*' for any request uri. Search-Key: '{requestUrl}. Setup: 1 responses: DELETE {requestUrl}");
}
public async Task GivenARequest_GetStringAsync_ReturnsAFakeResponse()
{
// Arrange.
const string requestUri = "http://www.something.com/some/website";
const string responseContent = "hi";
var options = new HttpMessageOptions
{
HttpMethod = HttpMethod.Get,
RequestUri = requestUri,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(responseContent)
}
};
var messageHandler = new FakeHttpMessageHandler(options);
string content;
using (var httpClient = new System.Net.Http.HttpClient(messageHandler))
{
// Act.
content = await httpClient.GetStringAsync(requestUri);
}
// Assert.
content.ShouldBe(responseContent);
}
public async Task GivenAPostRequestWithIncorrectlySetupOptions_PostAsync_ThrowsAnException(HttpContent expectedHttpContent,
HttpContent sentHttpContent)
{
// Arrange.
const string responseContent = "hi";
var options = new HttpMessageOptions
{
HttpMethod = HttpMethod.Post,
RequestUri = new Uri("http://www.something.com/some/website"),
HttpContent = expectedHttpContent,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(responseContent)
}
};
var messageHandler = new FakeHttpMessageHandler(options);
InvalidOperationException exception;
using (var httpClient = new System.Net.Http.HttpClient(messageHandler))
{
// Act.
exception =
await
Should.ThrowAsync <InvalidOperationException>(
async() => await httpClient.PostAsync("http://www.something.com/some/website", sentHttpContent));
}
// Assert.
exception.Message.ShouldStartWith("No HttpResponseMessage found");
}
public async Task HandleAsync_downloads_the_proper_Education_profile()
{
// ARRANGE
var text = _fixture.Create <string>();
var httpOption = new HttpMessageOptions
{
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(text)
}
};
var options = _fixture.Create <TranslateOptions>();
var sut = CreateSystemUnderTest(options, httpOption);
var context = _fixture.Create <NybusCommandContext <TranslateEducationCommand> >();
// continue...
// ACT
await sut.HandleAsync(_mockDispatcher.Object, context);
// ASSERT
Assert.That(httpOption.HttpResponseMessage.RequestMessage.RequestUri.ToString(), Is.EqualTo(string.Format(SingleTranslateCommandHandler.EducationProfileFormat, context.Command.EducationId)));
}
public async Task GivenAPostRequest_PostAsync_ReturnsAFakeResponse(HttpContent expectedHttpContent,
HttpContent sentHttpContent)
{
// Arrange.
Uri requestUri = new Uri("http://www.something.com/some/website");
const string responseContent = "hi";
var options = new HttpMessageOptions
{
HttpMethod = HttpMethod.Post,
RequestUri = requestUri,
HttpContent = expectedHttpContent, // This makes sure it's two separate memory references.
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(responseContent)
}
};
var messageHandler = new FakeHttpMessageHandler(options);
HttpResponseMessage message;
string content;
using (var httpClient = new System.Net.Http.HttpClient(messageHandler))
{
// Act.
message = await httpClient.PostAsync(requestUri, sentHttpContent);
content = await message.Content.ReadAsStringAsync();
}
// Assert.
message.StatusCode.ShouldBe(HttpStatusCode.OK);
content.ShouldBe(responseContent);
}
public async Task GivenAnHttpVerb_DeleteAsync_ReturnsAFakeResponse()
{
// Arrange.
const string requestUrl = "http://www.something.com/some/website";
const string responseData = "Delete me plz";
var messageResponse = FakeHttpMessageHandler.GetStringHttpResponseMessage(responseData);
var options = new HttpMessageOptions
{
RequestUri = requestUrl,
HttpMethod = HttpMethod.Delete,
HttpResponseMessage = messageResponse
};
var messageHandler = new FakeHttpMessageHandler(options);
HttpResponseMessage message;
string content;
using (var httpClient = HttpClientFactory.GetHttpClient(messageHandler))
{
// Act.
message = await httpClient.DeleteAsync(requestUrl);
content = await message.Content.ReadAsStringAsync();
}
// Assert.
message.StatusCode.ShouldBe(HttpStatusCode.OK);
content.ShouldBe(responseData);
}
[InlineData("*")] // Don't care what url they are hitting.
public async Task GivenSomeValidHttpRequest_GetSomeFooDataAsync_ReturnsAFoo(string endPoint)
{
// Arrange.
const string responseData = "{ \"Id\":69, \"Name\":\"Jane\" }";
var messageResponse = FakeHttpMessageHandler.GetStringHttpResponseMessage(responseData);
var options = new HttpMessageOptions
{
RequestUri = endPoint,
HttpResponseMessage = messageResponse
};
var messageHandler = new FakeHttpMessageHandler(options);
var myService = new MyService(messageHandler);
// Act.
// NOTE: network traffic will not leave your computer because you've faked the response, above.
var result = await myService.GetSomeFooDataAsync();
// Assert.
result.Id.ShouldBe(69); // Returned from GetSomeFooDataAsync.
result.Baa.ShouldBeNull();
options.NumberOfTimesCalled.ShouldBe(1);
}
public async Task Given_Parameters_When_Invoked_With_Error_Then_InvokeAsync_Should_Return_Result()
{
var endpoints = new Mock <EndpointsSettings>();
endpoints.SetupGet(p => p.HealthCheck).Returns("ping");
var settings = new Mock <ExternalApiSettings>();
settings.SetupGet(p => p.BaseUri).Returns("http://localhost");
settings.SetupGet(p => p.Endpoints).Returns(endpoints.Object);
var message = new HttpResponseMessage(HttpStatusCode.InternalServerError);
var options = new HttpMessageOptions()
{
HttpMethod = HttpMethod.Get,
HttpResponseMessage = message
};
var handler = new FakeHttpMessageHandler(options);
var httpClient = new HttpClient(handler);
var function = new HealthCheckFunction(settings.Object, httpClient);
var req = new Mock <HttpRequest>();
var result = await function.InvokeAsync <HttpRequest, IActionResult>(req.Object)
.ConfigureAwait(false);
result
.Should().BeOfType <ObjectResult>()
.And.Subject.As <ObjectResult>()
.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task HandleAsync_downloads_the_proper_Education_profile([Frozen] HttpMessageOptions httpOption, SingleTranslateCommandHandler sut, IDispatcher dispatcher, ICommandContext <TranslateEducationCommand> context)
{
await sut.HandleAsync(dispatcher, context);
var expectedRequestUri = string.Format(SingleTranslateCommandHandler.EducationProfileFormat, context.Command.EducationId);
Assert.That(httpOption.HttpResponseMessage.RequestMessage.RequestUri.ToString(), Is.EqualTo(expectedRequestUri));
}
public FakeHttpMessageHandler CreateFakeHttpMessageHandler(HttpResponseMessage response)
{
var options = new HttpMessageOptions()
{
HttpResponseMessage = response
};
var handler = new FakeHttpMessageHandler(options);
return(handler);
}
public static HttpClient GetFakeHttpClientNoResponseContent(HttpStatusCode httpStatus)
{
var responseData = FakeHttpMessageHandler.GetStringHttpResponseMessage("");
responseData.StatusCode = httpStatus;
var options = new HttpMessageOptions {
HttpResponseMessage = responseData,
};
var fakeMessageHandler = new FakeHttpMessageHandler(options);
return(new HttpClient(fakeMessageHandler));
}
public static HttpClient GetFakeHttpClient(string fileName, HttpStatusCode httpStatus)
{
var json = File.ReadAllText(fileName);
var responseData = FakeHttpMessageHandler.GetStringHttpResponseMessage(json);
responseData.StatusCode = httpStatus;
var options = new HttpMessageOptions {
HttpResponseMessage = responseData,
};
var fakeMessageHandler = new FakeHttpMessageHandler(options);
return(new HttpClient(fakeMessageHandler));
}
public async Task Multiple_requests_reuse_the_same_token(string methodName, OAuthOptions options, Uri requestUri, string accessToken, long expiresIn, TestClock clock)
{
Clock.Set(clock);
var method = new HttpMethod(methodName);
var httpOptions = new List <HttpMessageOptions>();
var refreshTokenOptions = new HttpMessageOptions
{
HttpMethod = HttpMethod.Post,
RequestUri = new Uri(requestUri, "/oauth/v1/token"),
HttpContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["grant_type"] = "refresh_token",
["client_id"] = options.ClientId,
["client_secret"] = options.SecretKey,
["redirect_uri"] = options.RedirectUri.ToString(),
["refresh_token"] = options.RefreshToken
}),
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = JsonContent.FromObject(new
{
access_token = accessToken,
expires_in = expiresIn
})
}
};
httpOptions.Add(refreshTokenOptions);
var option = new HttpMessageOptions
{
RequestUri = requestUri,
HttpMethod = method,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
};
httpOptions.Add(option);
var client = CreateClient(options, httpOptions.ToArray());
for (int i = 0; i < 2; i++)
{
var testRequest = new HttpRequestMessage(method, requestUri);
await client.SendAsync(testRequest);
}
Assert.That(refreshTokenOptions.NumberOfTimesCalled, Is.EqualTo(1));
}
public async Task GivenAnHttpMessageOptions_GetAsync_ReturnsAFakeResponse(HttpMessageOptions options)
{
// Arrange.
var fakeHttpMessageHandler = new FakeHttpMessageHandler(options);
// Act.
await DoGetAsync(RequestUri,
ExpectedContent,
fakeHttpMessageHandler,
options.Headers);
// Assert.
options.NumberOfTimesCalled.ShouldBe(1);
}
private HttpClient CreateClient(ApiKeyOptions options, HttpMessageOptions httpOptions)
{
var handler = new FakeHttpMessageHandler(httpOptions);
var wrapper = new OptionsWrapper <ApiKeyOptions>(options);
var authenticator = new ApiKeyHubSpotAuthenticator(wrapper)
{
InnerHandler = handler
};
var client = new HttpClient(authenticator);
return(client);
}
public async Task GivenAnHttpResponseMessage_GetAsync_ReturnsAFakeResponse()
{
// Arrange.
var httpResponseMessage = FakeHttpMessageHandler.GetStringHttpResponseMessage(ExpectedContent);
var options = new HttpMessageOptions
{
HttpResponseMessage = httpResponseMessage
};
var fakeHttpMessageHandler = new FakeHttpMessageHandler(options);
// Act & Assert.
await DoGetAsync(RequestUri,
ExpectedContent,
fakeHttpMessageHandler);
options.NumberOfTimesCalled.ShouldBe(1);
}
public void HandleAsync_throws_if_Italian_translation()
{
var httpOption = new HttpMessageOptions
{
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
};
var options = _fixture.Create <TranslateOptions>();
var sut = CreateSystemUnderTest(options, httpOption);
var context = _fixture.Create <NybusCommandContext <TranslateEducationCommand> >();
context.Command.ToLanguage = Language.Italian;
Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => sut.HandleAsync(_mockDispatcher.Object, context));
}
public async Task Single_request_is_authenticated_and_executed(string methodName, OAuthOptions options, Uri requestUri, string accessToken, long expiresIn, TestClock clock)
{
Clock.Set(clock);
var method = new HttpMethod(methodName);
var refreshTokenOptions = new HttpMessageOptions
{
HttpMethod = HttpMethod.Post,
RequestUri = new Uri(requestUri, "/oauth/v1/token"),
HttpContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["grant_type"] = "refresh_token",
["client_id"] = options.ClientId,
["client_secret"] = options.SecretKey,
["redirect_uri"] = options.RedirectUri.ToString(),
["refresh_token"] = options.RefreshToken
}),
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = JsonContent.FromObject(new
{
access_token = accessToken,
expires_in = expiresIn
})
}
};
var randomRequestOptions = new HttpMessageOptions
{
RequestUri = requestUri,
HttpMethod = method,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
};
var client = CreateClient(options, refreshTokenOptions, randomRequestOptions);
using var testRequest = new HttpRequestMessage(method, requestUri);
using var response = await client.SendAsync(testRequest);
Assert.That(refreshTokenOptions.NumberOfTimesCalled, Is.GreaterThan(0));
Assert.That(randomRequestOptions.HttpResponseMessage.RequestMessage.Headers.Authorization.Parameter, Is.EqualTo(accessToken));
}
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();
}
public async Task ApiKey_is_attached_to_request_in_querystring(string methodName, ApiKeyOptions options, Uri requestUri)
{
var method = new HttpMethod(methodName);
var httpOptions = new HttpMessageOptions
{
HttpMethod = method,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
};
var client = CreateClient(options, httpOptions);
using (var testRequest = new HttpRequestMessage(method, requestUri))
{
var response = await client.SendAsync(testRequest);
}
Assert.That(httpOptions.HttpResponseMessage.RequestMessage.RequestUri.Query, Contains.Substring($"hapikey={options.ApiKey}"));
}
private static List <HttpMessageOptions> GetSomeFakeHttpMessageOptions(HttpMessageOptions option)
{
return(new List <HttpMessageOptions>
{
new HttpMessageOptions
{
HttpMethod = HttpMethod.Get,
RequestUri = new Uri("http://some/url"),
HttpResponseMessage = SomeFakeResponse
},
new HttpMessageOptions
{
HttpMethod = HttpMethod.Get,
RequestUri = new Uri("http://another/url"),
HttpResponseMessage = SomeFakeResponse
},
option
});
}
public async Task Token_is_not_attached_if_request_fails(string methodName, OAuthOptions options, Uri requestUri, TestClock clock)
{
Clock.Set(clock);
var method = new HttpMethod(methodName);
var httpOptions = new List <HttpMessageOptions>();
var refreshTokenOptions = new HttpMessageOptions
{
HttpMethod = HttpMethod.Post,
RequestUri = new Uri(requestUri, "/oauth/v1/token"),
HttpContent = new FormUrlEncodedContent(new Dictionary <string, string>
{
["grant_type"] = "refresh_token",
["client_id"] = options.ClientId,
["client_secret"] = options.SecretKey,
["redirect_uri"] = options.RedirectUri.ToString(),
["refresh_token"] = options.RefreshToken
}),
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.Unauthorized)
};
httpOptions.Add(refreshTokenOptions);
var requestOption = new HttpMessageOptions
{
RequestUri = requestUri,
HttpMethod = method,
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
};
httpOptions.Add(requestOption);
var client = CreateClient(options, httpOptions.ToArray());
using var request = new HttpRequestMessage(method, requestUri);
using var response = await client.SendAsync(request);
Assert.That(requestOption.HttpResponseMessage.RequestMessage.Headers.Authorization, Is.Null);
}
public async Task GetProfile_requests_proper_profile()
{
var content = _fixture.Create <string>();
var httpOption = new HttpMessageOptions
{
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(content)
}
};
var sut = CreateSystemUnderTest(httpOption);
var educationId = _fixture.Create <int>();
var result = await sut.GetProfile(educationId);
Assert.That(httpOption.HttpResponseMessage.RequestMessage.RequestUri.ToString(), Is.EqualTo(string.Format(HttpClientEducationProfileDownloader.EducationUrlFormat, educationId)));
}
public async Task GetProfile_downloads_returned_content()
{
var content = _fixture.Create <string>();
var httpOption = new HttpMessageOptions
{
HttpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(content)
}
};
var sut = CreateSystemUnderTest(httpOption);
var educationId = _fixture.Create <int>();
var result = await sut.GetProfile(educationId);
Assert.That(result, Is.EqualTo(content));
}
