/// <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)); }