public override async Task <Response> SendAsync(TestContext ctx, CancellationToken cancellationToken) { byte[] data; string text; HttpContent content; switch (Operation.Type) { case WebClientOperationType.DownloadStringTaskAsync: text = await Client.DownloadStringTaskAsync(Uri).ConfigureAwait(false); return(new SimpleResponse(this, HttpStatusCode.OK, StringContent.CreateMaybeNull(text))); case WebClientOperationType.UploadStringTaskAsync: text = await Client.UploadStringTaskAsync(Uri, Operation.Content.AsString()).ConfigureAwait(false); content = !string.IsNullOrWhiteSpace(text) ? new StringContent(text) : null; return(new SimpleResponse(this, HttpStatusCode.OK, content)); case WebClientOperationType.OpenWriteTaskAsync: using (var stream = await Client.OpenWriteTaskAsync(Uri, Method).ConfigureAwait(false)) await Operation.Content.WriteToAsync(ctx, stream, cancellationToken); return(new SimpleResponse(this, HttpStatusCode.OK, null)); case WebClientOperationType.UploadValuesTaskAsync: data = await Client.UploadValuesTaskAsync(Uri, Method, Operation.Values).ConfigureAwait(false); content = data != null && data.Length > 0 ? new BinaryContent(data) : null; return(new SimpleResponse(this, HttpStatusCode.OK, content)); default: throw ctx.AssertFail(Operation.Type); } }
public override void ConfigureRequest(Request request, Uri uri) { base.ConfigureRequest(request, uri); request.Method = "DELETE"; request.Content = StringContent.CreateMaybeNull(Body); if (Flags == RequestFlags.ExplicitlySetLength) { request.SetContentLength(Body != null ? Body.Length : 0); } }
protected async virtual Task <Response> GetResponseFromHttp(TestContext ctx, HttpWebResponse response, WebException error, CancellationToken cancellationToken) { string content; var status = response.StatusCode; using (var reader = new StreamReader(response.GetResponseStream())) { content = await reader.ReadToEndAsync().ConfigureAwait(false); } response.Dispose(); return(new SimpleResponse(this, status, StringContent.CreateMaybeNull(content), error)); }
public async Task <Response> GetString(TestContext ctx, CancellationToken cancellationToken) { var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); cts.Token.Register(() => Client.CancelPendingRequests()); try { var body = await Client.GetStringAsync(RequestUri); return(new SimpleResponse(this, HttpStatusCode.OK, StringContent.CreateMaybeNull(body))); } catch (Exception ex) { return(new SimpleResponse(this, HttpStatusCode.InternalServerError, null, ex)); } finally { cts.Dispose(); } }
protected override async Task <Response> GetResponseFromHttp( TestContext ctx, HttpWebResponse response, WebException error, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); HttpContent content = null; ctx.LogDebug(4, $"{ME} GET RESPONSE FROM HTTP"); switch (TestRunner.EffectiveType) { case HttpInstrumentationTestType.AbortResponse: case HttpInstrumentationTestType.NtlmWhileQueued: return(await ReadWithTimeout(0, WebExceptionStatus.RequestCanceled).ConfigureAwait(false)); } using (var stream = response.GetResponseStream()) { switch (TestRunner.EffectiveType) { case HttpInstrumentationTestType.ReuseAfterPartialRead: content = await ReadStringAsBuffer(stream, 1234).ConfigureAwait(false); break; default: content = await ReadAsString(stream).ConfigureAwait(false); break; } } var status = response.StatusCode; response.Dispose(); finishedTcs.TrySetResult(true); return(new SimpleResponse(this, status, content, error)); async Task <Response> ReadWithTimeout(int timeout, WebExceptionStatus expectedStatus) { StreamReader reader = null; try { reader = new StreamReader(response.GetResponseStream()); var readTask = reader.ReadToEndAsync(); if (timeout > 0) { var timeoutTask = Task.Delay(timeout); var task = await Task.WhenAny(timeoutTask, readTask).ConfigureAwait(false); if (task == timeoutTask) { throw ctx.AssertFail("Timeout expired."); } } var ret = await readTask.ConfigureAwait(false); ctx.LogMessage($"EXPECTED ERROR: {ret}"); throw ctx.AssertFail("Expected exception."); } catch (WebException wexc) { ctx.Assert((WebExceptionStatus)wexc.Status, Is.EqualTo(expectedStatus)); return(new SimpleResponse(this, HttpStatusCode.InternalServerError, null, wexc)); } finally { finishedTcs.TrySetResult(true); } } async Task <HttpContent> ReadStringAsBuffer(Stream stream, int size) { var buffer = new byte[size]; var ret = await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false); ctx.Assert(ret, Is.EqualTo(buffer.Length)); return(StringContent.CreateMaybeNull(new ASCIIEncoding().GetString(buffer, 0, ret))); } async Task <HttpContent> ReadAsString(Stream stream) { using (var reader = new StreamReader(stream)) { string text = null; if (!reader.EndOfStream) { text = await reader.ReadToEndAsync().ConfigureAwait(false); } return(StringContent.CreateMaybeNull(text)); } } }
async Task <Response> GetResponseFromHttp(TestContext ctx, ChunkedRequest request, HttpWebResponse response, WebException error, CancellationToken cancellationToken) { var content = string.Empty; var status = response.StatusCode; ctx.Assert(status, Is.EqualTo(HttpStatusCode.OK), "success"); ctx.Assert(error, Is.Null, "null error"); var stream = response.GetResponseStream(); try { if (Type == ChunkContentType.BeginEndAsyncRead || Type == ChunkContentType.BeginEndAsyncReadNoWait) { var provider = DependencyInjector.Get <IStreamProvider> (); var buffer = new byte [1024]; var result = provider.BeginRead(stream, buffer, 0, buffer.Length, null, null); if (Type != ChunkContentType.BeginEndAsyncReadNoWait) { await Task.Run(() => { var timeout = ctx.Settings.DisableTimeouts ? -1 : 500; var waitResult = result.AsyncWaitHandle.WaitOne(timeout); ctx.Assert(waitResult, "WaitOne"); }); } var ret = provider.EndRead(stream, result); ctx.Assert(ret, Is.GreaterThan(0), "non-zero read"); content = Encoding.UTF8.GetString(buffer, 0, ret); } var reader = new StreamReader(stream); if (Type == ChunkContentType.SyncRead || Type == ChunkContentType.SyncReadTimeout) { content += reader.ReadToEnd(); } else { content += await reader.ReadToEndAsync(); } if (Type == ChunkContentType.ServerAbort) { ctx.Assert(content.Length, Is.EqualTo(1), "read one byte"); } if (ExpectException) { ctx.AssertFail("expected exception"); } } catch (IOException ex) { error = new WebException("failed to read response", ex, (XWebExceptionStatus)WebExceptionStatus.ResponseContentException, response); content = null; } catch (WebException ex) { if (Type == ChunkContentType.SyncReadTimeout) { ctx.Assert((WebExceptionStatus)ex.Status, Is.EqualTo(WebExceptionStatus.Timeout), "expected Timeout"); error = new WebException(ex.Message, ex, (XWebExceptionStatus)WebExceptionStatus.Timeout, response); } else if (Type == ChunkContentType.TruncatedChunk) { ctx.Assert((WebExceptionStatus)ex.Status, Is.EqualTo(WebExceptionStatus.ConnectionClosed), "expected ConnectionClosed"); error = new WebException(ex.Message, ex, (XWebExceptionStatus)WebExceptionStatus.ResponseContentTruncated, response); } else { throw; } content = null; } finally { stream.Dispose(); response.Dispose(); } return(new SimpleResponse(request, status, StringContent.CreateMaybeNull(content), error)); }
protected override async Task<Response> GetResponseFromHttp ( TestContext ctx, HttpWebResponse response, WebException error, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested (); HttpContent content = null; ctx.LogDebug (4, $"{ME} GET RESPONSE FROM HTTP"); switch (TestRunner.EffectiveType) { case HttpRequestTestType.ReadTimeout: return await ReadWithTimeout (5000, WebExceptionStatus.Timeout).ConfigureAwait (false); } using (var stream = response.GetResponseStream ()) { switch (TestRunner.EffectiveType) { case HttpRequestTestType.TestResponseStream: content = await TestResponseStream (stream).ConfigureAwait (false); break; case HttpRequestTestType.LargeChunkRead: content = await LargeChunkRead (stream).ConfigureAwait (false); break; case HttpRequestTestType.LargeGZipRead: content = await ReadAsString (stream).ConfigureAwait (false); break; case HttpRequestTestType.GZipWithLength: content = await GZipWithLength (stream).ConfigureAwait (false); break; case HttpRequestTestType.ResponseStreamCheckLength2: content = await ResponseStreamCheckLength (stream, true).ConfigureAwait (false); break; case HttpRequestTestType.ResponseStreamCheckLength: content = await ResponseStreamCheckLength (stream, false).ConfigureAwait (false); break; case HttpRequestTestType.GetNoLength: content = await GetNoLength (stream).ConfigureAwait (false); break; default: content = await ReadAsString (stream).ConfigureAwait (false); break; } } var status = response.StatusCode; response.Dispose (); finishedTcs.TrySetResult (true); return new SimpleResponse (this, status, content, error); async Task<Response> ReadWithTimeout (int timeout, WebExceptionStatus expectedStatus) { StreamReader reader = null; try { reader = new StreamReader (response.GetResponseStream ()); var readTask = reader.ReadToEndAsync (); if (timeout > 0) { var timeoutTask = Task.Delay (timeout); var task = await Task.WhenAny (timeoutTask, readTask).ConfigureAwait (false); if (task == timeoutTask) throw ctx.AssertFail ("Timeout expired."); } var ret = await readTask.ConfigureAwait (false); ctx.LogMessage ($"EXPECTED ERROR: {ret}"); throw ctx.AssertFail ("Expected exception."); } catch (WebException wexc) { ctx.Assert ((WebExceptionStatus)wexc.Status, Is.EqualTo (expectedStatus)); return new SimpleResponse (this, HttpStatusCode.InternalServerError, null, wexc); } finally { finishedTcs.TrySetResult (true); } } async Task<HttpContent> ReadAsString (Stream stream) { using (var reader = new StreamReader (stream)) { string text = null; if (!reader.EndOfStream) text = await reader.ReadToEndAsync ().ConfigureAwait (false); return StringContent.CreateMaybeNull (text); } } async Task<HttpContent> TestResponseStream (Stream stream) { var buffer = new byte[5]; var ret = await stream.ReadAsync (buffer, 4, 1).ConfigureAwait (false); ctx.Assert (ret, Is.EqualTo (1), "#A1"); ctx.Assert (buffer[4], Is.EqualTo ((byte)65), "#A2"); ret = await stream.ReadAsync (buffer, 0, 2); ctx.Assert (ret, Is.EqualTo (2), "#B1"); return Handler.Content; } async Task<HttpContent> LargeChunkRead (Stream stream) { var buffer = new byte[43]; var ret = await stream.ReadAsync (buffer, 0, buffer.Length).ConfigureAwait (false); ctx.Assert (ret, Is.EqualTo (ConnectionHandler.TheQuickBrownFox.Length), "#A1"); var text = Encoding.UTF8.GetString (buffer, 0, ret); return new StringContent (text); } async Task<HttpContent> GZipWithLength (Stream stream) { using (var ms = new MemoryStream ()) { await stream.CopyToAsync (ms, 16384).ConfigureAwait (false); var bytes = ms.ToArray (); var text = Encoding.UTF8.GetString (bytes, 0, bytes.Length); return new StringContent (text); } } async Task<HttpContent> ResponseStreamCheckLength (Stream stream, bool chunked) { await ctx.AssertException<NotSupportedException> (() => Task.FromResult (stream.Length), "Length should throw"); if (chunked) { ctx.Assert (response.ContentLength, Is.EqualTo (-1L), "ContentLength"); ctx.Assert (response.Headers["Transfer-Encoding"], Is.EqualTo ("chunked"), "chunked encoding"); } else { ctx.Assert (response.ContentLength, Is.EqualTo ((long)Handler.Content.Length), "ContentLength"); ctx.Assert (response.Headers["Content-Length"], Is.EqualTo (Handler.Content.Length.ToString ()), "Content-Length header"); } return await GZipWithLength (stream).ConfigureAwait (false); } async Task<HttpContent> GetNoLength (Stream stream) { ctx.Assert (response.ContentLength, Is.EqualTo (-1L), "ContentLength"); ctx.Assert (response.Headers["Content-Length"], Is.Null, "No Content-Length: header"); return await ReadAsString (stream); } }