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