public async Task OriginalContentStreamIsReturnedIfNotAsync() { var content = new AsyncContent() { MemoryStream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }) }; var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = content }; var mockHandler = new MockHttpClientHandler(httpRequestMessage => Task.FromResult(httpResponseMessage)); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); Response response = await ExecuteRequest(request, transport); content.CreateContentReadStreamAsyncCompletionSource.SetResult(null); Stream stream = response.ContentStream; Assert.AreSame(content.MemoryStream, stream); }
public async Task ProxySettingsAreReadFromEnvironment(string envVar, string url) { try { using (TestServer testServer = new TestServer(async context => { context.Response.Headers["Via"] = "Test-Proxy"; byte[] buffer = Encoding.UTF8.GetBytes("Hello"); await context.Response.Body.WriteAsync(buffer, 0, buffer.Length); })) { Environment.SetEnvironmentVariable(envVar, testServer.Address.ToString()); var transport = new HttpClientTransport(); Request request = transport.CreateRequest(); request.Uri.Reset(new Uri(url)); Response response = await ExecuteRequest(request, transport); Assert.True(response.Headers.TryGetValue("Via", out var via)); Assert.AreEqual("Test-Proxy", via); } } finally { Environment.SetEnvironmentVariable(envVar, null); } }
public async Task DoesntDisposeContentIfStreamGotReplaced() { DisposeTrackingHttpContent disposeTrackingContent = new DisposeTrackingHttpContent(); var mockHandler = new MockHttpClientHandler( httpRequestMessage => { return(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = disposeTrackingContent })); }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); Response response = await ExecuteRequest(request, transport); response.ContentStream = new MemoryStream(); response.Dispose(); Assert.False(disposeTrackingContent.IsDisposed); }
public async Task RequestContentIsNotDisposedOnSend() { var requests = new List <HttpRequestMessage>(); var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK); var mockHandler = new MockHttpClientHandler(httpRequestMessage => { requests.Add(httpRequestMessage); return(Task.FromResult(httpResponseMessage)); }); DisposeTrackingContent disposeTrackingContent = new DisposeTrackingContent(); var transport = new HttpClientTransport(new HttpClient(mockHandler)); using (Request request = transport.CreateRequest()) { request.Content = disposeTrackingContent; request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); await ExecuteRequest(request, transport); Assert.False(disposeTrackingContent.IsDisposed); } Assert.True(disposeTrackingContent.IsDisposed); }
public async Task CanGetAndSetRequestHeaders(string headerName, string headerValue, bool contentHeader) { IEnumerable <string> httpHeaderValues = null; var mockHandler = new MockHttpClientHandler( httpRequestMessage => { Assert.True( httpRequestMessage.Headers.TryGetValues(headerName, out httpHeaderValues) || httpRequestMessage.Content.Headers.TryGetValues(headerName, out httpHeaderValues)); }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpVerb.Get, new Uri("http://example.com:340")); request.Content = HttpPipelineRequestContent.Create(Array.Empty <byte>()); request.AddHeader(headerName, headerValue); Assert.True(request.TryGetHeader(headerName, out var value)); Assert.AreEqual(headerValue, value); Assert.True(request.TryGetHeader(headerName.ToUpper(), out value)); Assert.AreEqual(headerValue, value); CollectionAssert.AreEqual(new [] { new HttpHeader(headerName, headerValue), }, request.Headers); await ExecuteRequest(request, transport); Assert.AreEqual(headerValue, string.Join(",", httpHeaderValues)); }
public async Task CanGetAndSetResponseHeaders(string headerName, string headerValue, bool contentHeader) { var mockHandler = new MockHttpClientHandler( httpRequestMessage => { var responseMessage = new HttpResponseMessage((HttpStatusCode)200); if (contentHeader) { responseMessage.Content = new StreamContent(new MemoryStream()); Assert.True(responseMessage.Content.Headers.TryAddWithoutValidation(headerName, headerValue)); } else { Assert.True(responseMessage.Headers.TryAddWithoutValidation(headerName, headerValue)); } return(Task.FromResult(responseMessage)); }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); var response = await ExecuteRequest(request, transport); Assert.True(response.Headers.TryGetValue(headerName, out var value)); Assert.AreEqual(headerValue, value); Assert.True(response.Headers.TryGetValue(headerName.ToUpper(), out value)); Assert.AreEqual(headerValue, value); CollectionAssert.Contains(response.Headers, new HttpHeader(headerName, headerValue)); }
public void ClientRequestIdSetterThrowsOnNull() { var transport = new HttpClientTransport(); var request = transport.CreateRequest(); Assert.Throws <ArgumentNullException>(() => request.ClientRequestId = null); }
private static Request CreateRequest(HttpClientTransport transport, byte[] bytes = null) { var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); request.Content = HttpPipelineRequestContent.Create(bytes ?? Array.Empty <byte>()); return(request); }
private static Request CreateRequest(HttpClientTransport transport, byte[] bytes = null) { Request request = transport.CreateRequest(); request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); request.Content = RequestContent.Create(bytes ?? Array.Empty <byte>()); return(request); }
public async Task RequestIdCanBeOverriden() { var mockHandler = new MockHttpClientHandler(httpRequestMessage => { }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.RequestId = "123"; request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); var response = await ExecuteRequest(request, transport); Assert.AreEqual(request.RequestId, response.RequestId); }
public async Task SettingContentHeaderDoesNotSetContent(string headerName, string headerValue, bool contentHeader) { HttpContent httpMessageContent = null; var mockHandler = new MockHttpClientHandler(httpRequestMessage => { httpMessageContent = httpRequestMessage.Content; }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); request.Headers.Add(headerName, headerValue); await ExecuteRequest(request, transport); Assert.Null(httpMessageContent); }
public async Task RequestAndResponseHasRequestId() { var mockHandler = new MockHttpClientHandler(httpRequestMessage => { }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); Assert.IsNotEmpty(request.RequestId); Assert.True(Guid.TryParse(request.RequestId, out _)); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); var response = await ExecuteRequest(request, transport); Assert.AreEqual(request.RequestId, response.RequestId); }
public async Task RequestIdCanBeOverriden() { var mockHandler = new MockHttpClientHandler(httpRequestMessage => { }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.ClientRequestId = "123"; request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); Response response = await ExecuteRequest(request, transport); Assert.AreEqual(request.ClientRequestId, response.ClientRequestId); }
public async Task RequestAndResponseHasRequestId() { var mockHandler = new MockHttpClientHandler(httpRequestMessage => { }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); Assert.IsNotEmpty(request.ClientRequestId); Assert.True(Guid.TryParse(request.ClientRequestId, out _)); request.Method = RequestMethod.Get; request.UriBuilder.Uri = new Uri("https://example.com:340"); Response response = await ExecuteRequest(request, transport); Assert.AreEqual(request.ClientRequestId, response.ClientRequestId); }
public void TransportExceptionsAreWrapped() { using (TestServer testServer = new TestServer( context => { context.Abort(); return(Task.CompletedTask); })) { var transport = new HttpClientTransport(); Request request = transport.CreateRequest(); request.Uri.Reset(testServer.Address); RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() => await ExecuteRequest(request, transport)); Assert.AreEqual("An error occurred while sending the request.", exception.Message); } }
public async Task ContentLengthIsSetForArrayContent(HttpPipelineRequestContent content, int expectedLength) { long contentLength = 0; var mockHandler = new MockHttpClientHandler( httpRequestMessage => contentLength = httpRequestMessage.Content.Headers.ContentLength.Value ); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com")); request.Content = content; await ExecuteRequest(request, transport); Assert.AreEqual(expectedLength, contentLength); }
public async Task SettingHeaderOverridesDefaultContentLength() { long contentLength = 0; var mockHandler = new MockHttpClientHandler( httpRequestMessage => contentLength = httpRequestMessage.Content.Headers.ContentLength.Value); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com")); request.Content = HttpPipelineRequestContent.Create(new byte[10]); request.Headers.Add("Content-Length", "50"); await ExecuteRequest(request, transport); Assert.AreEqual(50, contentLength); }
public async Task ReasonPhraseIsExposed() { var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { ReasonPhrase = "Custom ReasonPhrase" }; var mockHandler = new MockHttpClientHandler(httpRequestMessage => Task.FromResult(httpResponseMessage)); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); Response response = await ExecuteRequest(request, transport); Assert.AreEqual("Custom ReasonPhrase", response.ReasonPhrase); }
public async Task SettingHeaderOverridesDefaultHost() { string host = null; var mockHandler = new MockHttpClientHandler( httpRequestMessage => { host = httpRequestMessage.Headers.Host; }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); request.Headers.Add("Host", "example.org"); await ExecuteRequest(request, transport); Assert.AreEqual("example.org", host); }
public async Task CanGetAndSetMultiValueResponseHeaders(string headerName, string headerValue, bool contentHeader) { var anotherHeaderValue = headerValue + "1"; var joinedHeaderValues = headerValue + "," + anotherHeaderValue; var mockHandler = new MockHttpClientHandler( httpRequestMessage => { var responseMessage = new HttpResponseMessage((HttpStatusCode)200); if (contentHeader) { responseMessage.Content = new StreamContent(new MemoryStream()); Assert.True(responseMessage.Content.Headers.TryAddWithoutValidation(headerName, headerValue)); Assert.True(responseMessage.Content.Headers.TryAddWithoutValidation(headerName, anotherHeaderValue)); } else { Assert.True(responseMessage.Headers.TryAddWithoutValidation(headerName, headerValue)); Assert.True(responseMessage.Headers.TryAddWithoutValidation(headerName, anotherHeaderValue)); } return(Task.FromResult(responseMessage)); }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); Response response = await ExecuteRequest(request, transport); Assert.True(response.Headers.Contains(headerName)); Assert.True(response.Headers.TryGetValue(headerName, out var value)); Assert.AreEqual(joinedHeaderValues, value); Assert.True(response.Headers.TryGetValues(headerName, out IEnumerable <string> values)); CollectionAssert.AreEqual(new[] { headerValue, anotherHeaderValue }, values); CollectionAssert.Contains(response.Headers, new HttpHeader(headerName, joinedHeaderValues)); }
public async Task CanGetAndSetMethod(HttpPipelineMethod method, string expectedMethod) { HttpMethod httpMethod = null; var mockHandler = new MockHttpClientHandler( httpRequestMessage => { httpMethod = httpRequestMessage.Method; }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(method, new Uri("http://example.com:340")); Assert.AreEqual(method, request.Method); await ExecuteRequest(request, transport); Assert.AreEqual(expectedMethod, httpMethod.Method); }
public async Task CanGetAndSetUri() { Uri requestUri = null; var mockHandler = new MockHttpClientHandler( httpRequestMessage => { requestUri = httpRequestMessage.RequestUri; }); var expectedUri = new Uri("http://example.com:340"); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, expectedUri); Assert.AreEqual(expectedUri.ToString(), request.UriBuilder.ToString()); await ExecuteRequest(request, transport); Assert.AreEqual(expectedUri, requestUri); }
public async Task ResponseHeadersAreSplit() { using (TestServer testServer = new TestServer( async context => { context.Response.Headers.Add("Sync-Token", new[] { "A", "B" }); byte[] buffer = Encoding.UTF8.GetBytes("Hello"); await context.Response.Body.WriteAsync(buffer, 0, buffer.Length); })) { var transport = new HttpClientTransport(); Request request = transport.CreateRequest(); request.UriBuilder.Uri = testServer.Address; Response response = await ExecuteRequest(request, transport); Assert.True(response.Headers.TryGetValues("Sync-Token", out var tokens)); Assert.AreEqual(2, tokens.Count()); CollectionAssert.AreEqual(new[] { "A", "B" }, tokens); } }
public async Task ResponseHeadersAreNotSplit() { using (TestServer testServer = new TestServer( async context => { context.Response.Headers.Add("Sync-Token", "A,B"); byte[] buffer = Encoding.UTF8.GetBytes("Hello"); await context.Response.Body.WriteAsync(buffer, 0, buffer.Length); })) { var transport = new HttpClientTransport(); Request request = transport.CreateRequest(); request.Uri.Reset(testServer.Address); Response response = await ExecuteRequest(request, transport); Assert.True(response.Headers.TryGetValues("Sync-Token", out System.Collections.Generic.IEnumerable <string> tokens)); Assert.AreEqual(1, tokens.Count()); CollectionAssert.AreEqual(new[] { "A,B" }, tokens); } }
public async Task ContentStreamIsReturnedSynchronously() { var content = new AsyncContent() { MemoryStream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }) }; var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK) { Content = content }; var mockHandler = new MockHttpClientHandler(httpRequestMessage => Task.FromResult(httpResponseMessage)); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.Method = RequestMethod.Get; request.Uri.Reset(new Uri("https://example.com:340")); Response response = await ExecuteRequest(request, transport); byte[] data = new byte[5]; Stream stream = response.ContentStream; Task <int> firstRead = stream.ReadAsync(data, 0, 5); Assert.False(firstRead.IsCompleted); content.CreateContentReadStreamAsyncCompletionSource.SetResult(null); Assert.AreEqual(5, await firstRead); // Exercise stream features stream.Position = 3; stream.Seek(-1, SeekOrigin.Current); var secondReadLength = await stream.ReadAsync(data, 0, 5); Assert.AreEqual(3, secondReadLength); Assert.False(stream.CanWrite); Assert.True(stream.CanSeek); Assert.True(stream.CanRead); Assert.Throws <NotSupportedException>(() => stream.Write(null, 0, 0)); Assert.Throws <NotSupportedException>(() => stream.SetLength(5)); }
public async Task HostHeaderSetFromUri() { string host = null; Uri uri = null; var mockHandler = new MockHttpClientHandler( httpRequestMessage => { uri = httpRequestMessage.RequestUri; host = httpRequestMessage.Headers.Host; }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); await ExecuteRequest(request, transport); // HttpClientHandler would correctly set Host header from UriBuilder when it's not set explicitly Assert.AreEqual("http://example.com:340/", uri.ToString()); Assert.Null(host); }
public async Task CanGetAndSetContent() { byte[] requestBytes = null; var mockHandler = new MockHttpClientHandler( async httpRequestMessage => { requestBytes = await httpRequestMessage.Content.ReadAsByteArrayAsync(); }); var bytes = Encoding.ASCII.GetBytes("Hello world"); var content = HttpPipelineRequestContent.Create(bytes); var transport = new HttpClientTransport(new HttpClient(mockHandler)); var request = transport.CreateRequest(null); request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340")); request.Content = content; Assert.AreEqual(content, request.Content); await ExecuteRequest(request, transport); CollectionAssert.AreEqual(bytes, requestBytes); }
public async Task StreamRequestContentCanBeSentMultipleTimes() { var requests = new List <HttpRequestMessage>(); var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK); var mockHandler = new MockHttpClientHandler(httpRequestMessage => { requests.Add(httpRequestMessage); return(Task.FromResult(httpResponseMessage)); }); var transport = new HttpClientTransport(new HttpClient(mockHandler)); Request request = transport.CreateRequest(); request.Content = HttpPipelineRequestContent.Create(new MemoryStream(new byte[] { 1, 2, 3 })); request.SetRequestLine(RequestMethod.Get, new Uri("http://example.com:340")); await ExecuteRequest(request, transport); await ExecuteRequest(request, transport); Assert.AreEqual(2, requests.Count); }
public async Task StreamReadingExceptionsAreIOExceptions() { var tcs = new TaskCompletionSource <object>(TaskCreationOptions.RunContinuationsAsynchronously); using (TestServer testServer = new TestServer( async context => { context.Response.ContentLength = 20; await context.Response.WriteAsync("Hello"); await tcs.Task; context.Abort(); })) { var transport = new HttpClientTransport(); Request request = transport.CreateRequest(); request.Uri.Reset(testServer.Address); Response response = await ExecuteRequest(request, transport); tcs.SetResult(null); Assert.ThrowsAsync <IOException>(async() => await response.ContentStream.CopyToAsync(new MemoryStream())); } }