public async Task CopyToAsync(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetAsyncUri(LargeDownload_Handler);
var task = ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
HttpResponseMessage response;
if (ctx.ThreadingMode == ThreadingMode.MainThread)
{
response = await task;
}
else
{
response = await task.ConfigureAwait(false);
if (ctx.ThreadingMode == ThreadingMode.ThreadPool)
{
await Task.Yield();
}
}
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
using (var ms = new MemoryStream(TotalSize)) {
await response.Content.CopyToAsync(ms);
ctx.Assert(ms.Position, Is.EqualTo(TotalSize), "#101");
}
}
public async Task PutAndDelete(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = GetRandomUri();
var content = new StringContent(Text);
var response = await ctx.Client.PutAsync(
uri, content, cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
var response2 = await ctx.Client.DeleteAsync(uri, cancellationToken);
ctx.AutoDispose(response2);
ctx.Assert(response2.IsSuccessStatusCode, Is.True, "#101");
var response3 = await ctx.Client.GetAsync(uri, cancellationToken);
ctx.AutoDispose(response3);
ctx.Assert(response3.StatusCode, Is.EqualTo(HttpStatusCode.NotFound), "#102");
}
public async Task TestRedirection (HttpClientTestContext ctx)
{
var uri = Server.GetUri (HandleRequest);
ctx.Handler.AllowAutoRedirect = true;
var result = await ctx.Client.GetStringAsync (uri).ConfigureAwait (false);
ctx.Assert (result, Is.EqualTo (Text));
}
public async Task GetByteArrayAsync(HttpClientTestContext ctx)
{
var uri = Server.GetUri(SimpleHtml_Handler);
var data = await ctx.Client.GetByteArrayAsync(uri).ConfigureAwait(false);
ctx.Assert(data, Is.EqualTo(Encoding.UTF8.GetBytes(Text)));
}
public async Task SynchronousRead(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetAsyncUri(LargeDownload_Handler);
var response = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
/*
* Since we used ConfigureAwait(false) above, this should send
* us to the ThreadPool.
*/
await Task.Yield();
ctx.Assert(SynchronizationContext.Current, Is.Null, "#101");
var stream = await response.Content.ReadAsStreamAsync();
ctx.AutoDispose(stream);
ctx.Assert(SynchronizationContext.Current, Is.Null, "#102");
byte[] buffer = new byte [16];
int ret = stream.Read(buffer, 0, buffer.Length);
ctx.Assert(ret, Is.EqualTo(buffer.Length), "#103");
}
public async Task RandomDataAsByteArray(HttpClientTestContext ctx)
{
var uri = Server.GetUri(RandomData_Handler);
var data = await ctx.Client.GetByteArrayAsync(uri).ConfigureAwait(false);
ctx.Assert(data, Is.EqualTo(Data));
}
public async Task ClientHandlerSettings(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(ClientHandlerSettings_Handler);
ctx.Handler.AllowAutoRedirect = true;
ctx.Handler.AutomaticDecompression = DecompressionMethods.GZip;
ctx.Handler.MaxAutomaticRedirections = 33;
ctx.Handler.MaxRequestContentBufferSize = 5555;
ctx.Handler.PreAuthenticate = true;
ctx.Handler.CookieContainer.Add(uri, new Cookie("mycookie", "vv"));
ctx.Handler.UseCookies = true;
ctx.Handler.UseDefaultCredentials = true;
if (Server.IsLocal)
{
ctx.Handler.Proxy = new WebProxy("ee");
ctx.Handler.UseProxy = true;
}
var request = new HttpRequestMessage(HttpMethod.Get, uri);
request.Version = HttpVersion.Version10;
request.Headers.Add("Keep-Alive", "false");
var response = await ctx.Client.SendAsync(
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), "#100");
ctx.Assert(await response.Content.ReadAsStringAsync(), Is.Empty, "#101");
}
public async Task DigestPreAuthentication(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var config = ctx.GetConfiguration <WebDavConfiguration> ();
var random = new Random();
var text = random.Next().ToString("x");
var uri = new Uri(config.Server);
var cache = new CredentialCache();
cache.Add(uri, "Basic", new NetworkCredential("invalid", text));
cache.Add(uri, "Digest", new NetworkCredential(config.UserName, config.Password));
ctx.Handler.Credentials = cache;
ctx.Handler.PreAuthenticate = true;
var response = await ctx.Client.GetAsync(
uri, cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
ctx.Expect(response.IsSuccessStatusCode, Is.True, "#100");
var response2 = await ctx.Client.GetAsync(
uri, cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response2);
ctx.Expect(response2.IsSuccessStatusCode, Is.True, "#101");
}
public async Task Simple(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(Post_Handler);
var request = new HttpRequestMessage(HttpMethod.Post, uri);
request.Content = new StringContent(Text);
HttpResponseMessage response;
var task = ctx.Client.SendAsync(request, cancellationToken);
if (ctx.ThreadingMode == ThreadingMode.MainThread)
{
response = await task;
}
else
{
response = await task.ConfigureAwait(false);
if (ctx.ThreadingMode == ThreadingMode.ThreadPool)
{
await Task.Yield();
}
}
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task GetStringAsync(HttpClientTestContext ctx)
{
var uri = Server.GetUri(SimpleHtml_Handler);
var text = await ctx.Client.GetStringAsync(uri).ConfigureAwait(false);
ctx.Assert(text, Is.EqualTo(Text));
}
public async Task TestNoRedirection(HttpClientTestContext ctx)
{
var uri = Server.GetUri(HandleRequest);
ctx.Handler.AllowAutoRedirect = false;
await ctx.Client.GetStringAsync(uri).ConfigureAwait(false);
}
public async Task GetAsync (HttpClientTestContext ctx)
{
var uri = Server.GetUri (Error500Handler);
var res = await ctx.Client.GetAsync (uri).ConfigureAwait (false);
ctx.AutoDispose (res);
ctx.Assert (res.StatusCode, Is.EqualTo (HttpStatusCode.InternalServerError));
}
public async Task GetAsync(HttpClientTestContext ctx)
{
var uri = Server.GetUri(Error500Handler);
var res = await ctx.Client.GetAsync(uri).ConfigureAwait(false);
ctx.AutoDispose(res);
ctx.Assert(res.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
}
public async Task TestRedirection(HttpClientTestContext ctx)
{
var uri = Server.GetUri(HandleRequest);
ctx.Handler.AllowAutoRedirect = true;
var result = await ctx.Client.GetStringAsync(uri).ConfigureAwait(false);
ctx.Assert(result, Is.EqualTo(Text));
}
public void SetUp (HttpClientTestContext ctx)
{
var config = (WebDavConfiguration)ctx.Fixture.Configuration;
Server = new Uri (config.Server);
var cache = new CredentialCache ();
cache.Add (Server, "Digest", new NetworkCredential (config.UserName, config.Password));
ctx.Handler.Credentials = cache;
}
public void SetUp(HttpClientTestContext ctx)
{
var config = (WebDavConfiguration)ctx.Fixture.Configuration;
Server = new Uri(config.Server);
var cache = new CredentialCache();
cache.Add(Server, "Digest", new NetworkCredential(config.UserName, config.Password));
ctx.Handler.Credentials = cache;
}
public async Task GetAsync (HttpClientTestContext ctx)
{
var uri = Server.GetUri (SimpleHtml_Handler);
var result = await ctx.Client.GetAsync (uri).ConfigureAwait (false);
ctx.AutoDispose (result);
ctx.Assert (result.StatusCode, Is.EqualTo (HttpStatusCode.OK));
var text = await result.Content.ReadAsStringAsync ();
ctx.Assert (text, Is.EqualTo (Text));
}
public async Task TestStatusCode (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (HandleRequest);
ctx.Handler.AllowAutoRedirect = false;
var response = await ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
ctx.Assert (response.StatusCode, Is.EqualTo (HttpStatusCode.Moved));
}
public async Task TestStatusCode(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(HandleRequest);
ctx.Handler.AllowAutoRedirect = false;
var response = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
ctx.Assert(response.StatusCode, Is.EqualTo(HttpStatusCode.Moved));
}
public async Task Put (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = GetRandomUri ();
var content = new StringContent (Text);
var response = await ctx.Client.PutAsync (
uri, content, cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task GetAsync(HttpClientTestContext ctx)
{
var uri = Server.GetUri(SimpleHtml_Handler);
var result = await ctx.Client.GetAsync(uri).ConfigureAwait(false);
ctx.AutoDispose(result);
ctx.Assert(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
var text = await result.Content.ReadAsStringAsync();
ctx.Assert(text, Is.EqualTo(Text));
}
public async Task Put(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = GetRandomUri();
var content = new StringContent(Text);
var response = await ctx.Client.PutAsync(
uri, content, cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task Download(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetAsyncUri(LargeDownload_Handler);
var task = ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
HttpResponseMessage response;
if (ctx.ThreadingMode == ThreadingMode.MainThread)
{
response = await task;
}
else
{
response = await task.ConfigureAwait(false);
if (ctx.ThreadingMode == ThreadingMode.ThreadPool)
{
await Task.Yield();
}
}
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
var stream = await response.Content.ReadAsStreamAsync();
ctx.AutoDispose(stream);
long total = 0;
var buffer = new byte [1000];
while (true)
{
int ret = await stream.ReadAsync(buffer, 0, buffer.Length);
ctx.Assert(ret, Is.GreaterThanOrEqualTo(0), "#101");
if (ret == 0)
{
break;
}
total += ret;
}
ctx.Assert(total, Is.EqualTo(TotalSize), "#102");
}
public async Task GetErrorMessage (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (Error500Handler);
var res = await ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseContentRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (res);
ctx.Assert (res.StatusCode, Is.EqualTo (HttpStatusCode.InternalServerError));
var text = await res.Content.ReadAsStringAsync ();
ctx.Assert (text, Is.EqualTo (Text));
}
public async Task BasicAuthentication (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (BasicAuthentication_Handler);
ctx.Handler.Credentials = new NetworkCredential ("monkey", "banana");
var response = await ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Expect (response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task GetErrorMessage(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(Error500Handler);
var res = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseContentRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(res);
ctx.Assert(res.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
var text = await res.Content.ReadAsStringAsync();
ctx.Assert(text, Is.EqualTo(Text));
}
public async Task Default(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(DefaultHandler);
var request = new HttpRequestMessage(HttpMethod.Get, uri);
var response = await ctx.Client.SendAsync(
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), "#100");
ctx.Assert(await response.Content.ReadAsStringAsync(), Is.Empty, "#101");
}
public async Task BasicAuthentication(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(BasicAuthentication_Handler);
ctx.Handler.Credentials = new NetworkCredential("monkey", "banana");
var response = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Expect(response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task Default (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (DefaultHandler);
var request = new HttpRequestMessage (HttpMethod.Get, uri);
var response = await ctx.Client.SendAsync (
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.StatusCode, Is.EqualTo (HttpStatusCode.OK), "#100");
ctx.Assert (await response.Content.ReadAsStringAsync (), Is.Empty, "#101");
}
public async Task ContentAsByteArray(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(RandomData_Handler);
var response = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
var data = await response.Content.ReadAsByteArrayAsync();
ctx.Expect(data, Is.EqualTo(Data), "#101");
}
public async Task KeepAlive_Version1_0(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(KeepAlive_Version1_0_Handler);
var req = new HttpRequestMessage(HttpMethod.Get, uri);
req.Version = HttpVersion.Version10;
req.Headers.Add("Keep-Alive", "false");
var response = await ctx.Client.SendAsync(
req, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
}
public async Task DownloadWithDelay(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetAsyncUri(RandomData_Handler);
var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
cts.CancelAfter(HeaderTimeout);
HttpResponseMessage response;
try {
response = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead, cts.Token);
ctx.AutoDispose(response);
} finally {
cts.Dispose();
}
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
var cts2 = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
cts2.Token.Register(() => response.Content.Dispose());
cts2.CancelAfter(DataTimeout);
byte[] data;
try {
data = await response.Content.ReadAsByteArrayAsync();
} finally {
cts2.Dispose();
}
ctx.Assert(data.Length, Is.EqualTo(Header.Length + Simple.Data.Length), "#101");
var header = new byte [Header.Length];
Buffer.BlockCopy(data, 0, header, 0, header.Length);
var data2 = new byte [Simple.Data.Length];
Buffer.BlockCopy(data, header.Length, data2, 0, data2.Length);
ctx.Expect(header, Is.EqualTo(Header), "#102");
ctx.Expect(data2, Is.EqualTo(Simple.Data), "#103");
}
public async Task DigestAuthentication(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var config = ctx.GetConfiguration <WebDavConfiguration> ();
var uri = new Uri(config.Server);
var cache = new CredentialCache();
cache.Add(uri, "Digest", new NetworkCredential(config.UserName, config.Password));
ctx.Handler.Credentials = cache;
var response = await ctx.Client.GetAsync(
uri, cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
ctx.Expect(response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task GetRandomData(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = ServiceURI + "/GetRandomData";
var body = "count=100" + Environment.NewLine;
var request = new HttpRequestMessage(HttpMethod.Post, uri);
request.Content = new StringContent(body);
var ctype = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
request.Content.Headers.ContentType = ctype;
var response = await ctx.Client.SendAsync(
request, cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
var text = await response.Content.ReadAsStringAsync();
ctx.Log("POST: {0} {1} {2}", ctx.IsDefaultHandler, response.ReasonPhrase, text);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
var settings = new XmlReaderSettings();
settings.IgnoreWhitespace = true;
settings.IgnoreComments = true;
var reader = XmlReader.Create(new StringReader(text), settings);
ctx.Assert(reader.Read(), Is.True, "#101");
ctx.Assert(reader.NodeType, Is.EqualTo(XmlNodeType.XmlDeclaration), "#102");
ctx.Assert(reader.Read(), Is.True, "#103");
ctx.Assert(reader.NodeType, Is.EqualTo(XmlNodeType.Element), "#104");
var buffer = new byte [256];
var ret = reader.ReadElementContentAsBase64(buffer, 0, 256);
ctx.Assert(ret, Is.EqualTo(100), "#105");
}
public async Task ContentCopyToAsync(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(RandomData_Handler);
var response = await ctx.Client.GetAsync(
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.IsSuccessStatusCode, Is.True, "#100");
using (var stream = new MemoryStream()) {
await response.Content.CopyToAsync(stream);
var data = stream.GetBuffer();
ctx.Expect(data, Is.EqualTo(Data), "#101");
}
}
public async Task MaxResponseContentBufferSize(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(MaxResponseContentBufferSize_Handler);
ctx.Client.MaxResponseContentBufferSize = 1000;
var request = new HttpRequestMessage(HttpMethod.Get, uri);
var response = await ctx.Client.SendAsync(
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), "#101");
var result = await response.Content.ReadAsStringAsync();
ctx.Expect(result.Length, Is.EqualTo(MaxResponseContentBufferSize_size), "#100");
}
public async Task MaxResponseContentBufferSize_Error(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(MaxResponseContentBufferSize_Handler);
ctx.Client.MaxResponseContentBufferSize = 1000;
var request = new HttpRequestMessage(HttpMethod.Get, uri);
try {
var response = await ctx.Client.SendAsync(
request, HttpCompletionOption.ResponseContentRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
ctx.Assert(false, "#2");
} catch (AggregateException e) {
ctx.Assert(e.InnerException, Is.InstanceOf(typeof(HttpRequestException)), "#3");
} catch (HttpRequestException) {
;
}
}
public async Task DownloadWithDelay (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetAsyncUri (RandomData_Handler);
var cts = CancellationTokenSource.CreateLinkedTokenSource (cancellationToken);
cts.CancelAfter (HeaderTimeout);
HttpResponseMessage response;
try {
response = await ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseHeadersRead, cts.Token);
ctx.AutoDispose (response);
} finally {
cts.Dispose ();
}
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
var cts2 = CancellationTokenSource.CreateLinkedTokenSource (cancellationToken);
cts2.Token.Register (() => response.Content.Dispose ());
cts2.CancelAfter (DataTimeout);
byte[] data;
try {
data = await response.Content.ReadAsByteArrayAsync ();
} finally {
cts2.Dispose ();
}
ctx.Assert (data.Length, Is.EqualTo (Header.Length + Simple.Data.Length), "#101");
var header = new byte [Header.Length];
Buffer.BlockCopy (data, 0, header, 0, header.Length);
var data2 = new byte [Simple.Data.Length];
Buffer.BlockCopy (data, header.Length, data2, 0, data2.Length);
ctx.Expect (header, Is.EqualTo (Header), "#102");
ctx.Expect (data2, Is.EqualTo (Simple.Data), "#103");
}
public async Task Simple (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (Post_Handler);
var request = new HttpRequestMessage (HttpMethod.Post, uri);
request.Content = new StringContent (Text);
HttpResponseMessage response;
var task = ctx.Client.SendAsync (request, cancellationToken);
if (ctx.ThreadingMode == ThreadingMode.MainThread)
response = await task;
else {
response = await task.ConfigureAwait (false);
if (ctx.ThreadingMode == ThreadingMode.ThreadPool)
await Task.Yield ();
}
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task Content(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri(ContentHandler);
var request = new HttpRequestMessage(HttpMethod.Get, uri);
ctx.Assert(request.Headers.TryAddWithoutValidation("aa", "vv"), Is.True, "#0");
var response = await ctx.Client.SendAsync(
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait(false);
ctx.AutoDispose(response);
Server.CheckException(response);
ctx.Assert(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), "#101");
ctx.Expect(await response.Content.ReadAsStringAsync(), Is.EqualTo("7K"), "#100");
var headers = response.Headers;
IEnumerable <string> values;
if (ctx.Expect(headers.TryGetValues("Transfer-Encoding", out values), Is.True, "#102"))
{
// CFNetwork automatically combines all chunks.
if (ctx.IsDefaultHandler)
{
ctx.Expect(values.First(), Is.EqualTo("chunked"), "#102a");
ctx.Expect(headers.TransferEncodingChunked, Is.True, "#102b");
}
else
{
ctx.Expect(values.First(), Is.EqualTo("Identity"), "#102c");
ctx.Expect(headers.TransferEncodingChunked, Is.Null, "#102d");
}
}
}
public async Task Download (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetAsyncUri (LargeDownload_Handler);
var task = ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
HttpResponseMessage response;
if (ctx.ThreadingMode == ThreadingMode.MainThread)
response = await task;
else {
response = await task.ConfigureAwait (false);
if (ctx.ThreadingMode == ThreadingMode.ThreadPool)
await Task.Yield ();
}
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
var stream = await response.Content.ReadAsStreamAsync ();
ctx.AutoDispose (stream);
long total = 0;
var buffer = new byte [1000];
while (true) {
int ret = await stream.ReadAsync (buffer, 0, buffer.Length);
ctx.Assert (ret, Is.GreaterThanOrEqualTo (0), "#101");
if (ret == 0)
break;
total += ret;
}
ctx.Assert (total, Is.EqualTo (TotalSize), "#102");
}
public async Task GetRandomData (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = ServiceURI + "/GetRandomData";
var body = "count=100" + Environment.NewLine;
var request = new HttpRequestMessage (HttpMethod.Post, uri);
request.Content = new StringContent (body);
var ctype = new MediaTypeHeaderValue ("application/x-www-form-urlencoded");
request.Content.Headers.ContentType = ctype;
var response = await ctx.Client.SendAsync (
request, cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
var text = await response.Content.ReadAsStringAsync ();
ctx.Log ("POST: {0} {1} {2}", ctx.IsDefaultHandler, response.ReasonPhrase, text);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
var settings = new XmlReaderSettings ();
settings.IgnoreWhitespace = true;
settings.IgnoreComments = true;
var reader = XmlReader.Create (new StringReader (text), settings);
ctx.Assert (reader.Read (), Is.True, "#101");
ctx.Assert (reader.NodeType, Is.EqualTo (XmlNodeType.XmlDeclaration), "#102");
ctx.Assert (reader.Read (), Is.True, "#103");
ctx.Assert (reader.NodeType, Is.EqualTo (XmlNodeType.Element), "#104");
var buffer = new byte [256];
var ret = reader.ReadElementContentAsBase64 (buffer, 0, 256);
ctx.Assert (ret, Is.EqualTo (100), "#105");
}
public async Task KeepAlive_Version1_0 (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (KeepAlive_Version1_0_Handler);
var req = new HttpRequestMessage (HttpMethod.Get, uri);
req.Version = HttpVersion.Version10;
req.Headers.Add ("Keep-Alive", "false");
var response = await ctx.Client.SendAsync (
req, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
}
public async Task GetByteArrayAsync (HttpClientTestContext ctx)
{
var uri = Server.GetUri (SimpleHtml_Handler);
var data = await ctx.Client.GetByteArrayAsync (uri).ConfigureAwait (false);
ctx.Assert (data, Is.EqualTo (Encoding.UTF8.GetBytes (Text)));
}
public async Task GetStringAsync (HttpClientTestContext ctx)
{
var uri = Server.GetUri (SimpleHtml_Handler);
var text = await ctx.Client.GetStringAsync (uri).ConfigureAwait (false);
ctx.Assert (text, Is.EqualTo (Text));
}
public async Task ContentAsByteArray (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (RandomData_Handler);
var response = await ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
var data = await response.Content.ReadAsByteArrayAsync ();
ctx.Expect (data, Is.EqualTo (Data), "#101");
}
public async Task ContentCopyToAsync (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (RandomData_Handler);
var response = await ctx.Client.GetAsync (
uri, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
using (var stream = new MemoryStream ()) {
await response.Content.CopyToAsync (stream);
var data = stream.GetBuffer ();
ctx.Expect (data, Is.EqualTo (Data), "#101");
}
}
public async Task RandomDataAsByteArray (HttpClientTestContext ctx)
{
var uri = Server.GetUri (RandomData_Handler);
var data = await ctx.Client.GetByteArrayAsync (uri).ConfigureAwait (false);
ctx.Assert (data, Is.EqualTo (Data));
}
public async Task MaxResponseContentBufferSize_Error (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (MaxResponseContentBufferSize_Handler);
ctx.Client.MaxResponseContentBufferSize = 1000;
var request = new HttpRequestMessage (HttpMethod.Get, uri);
try {
var response = await ctx.Client.SendAsync (
request, HttpCompletionOption.ResponseContentRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
ctx.Assert (false, "#2");
} catch (AggregateException e) {
ctx.Assert (e.InnerException, Is.InstanceOfType (typeof(HttpRequestException)), "#3");
} catch (HttpRequestException) {
;
}
}
public Task DigestAuthentication_Default (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
return DigestAuthentication (ctx, cancellationToken);
}
public async Task TestNoRedirection (HttpClientTestContext ctx)
{
var uri = Server.GetUri (HandleRequest);
ctx.Handler.AllowAutoRedirect = false;
await ctx.Client.GetStringAsync (uri).ConfigureAwait (false);
}
public async Task ClientHandlerSettings (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (ClientHandlerSettings_Handler);
ctx.Handler.AllowAutoRedirect = true;
ctx.Handler.AutomaticDecompression = DecompressionMethods.GZip;
ctx.Handler.MaxAutomaticRedirections = 33;
ctx.Handler.MaxRequestContentBufferSize = 5555;
ctx.Handler.PreAuthenticate = true;
ctx.Handler.CookieContainer.Add (uri, new Cookie ("mycookie", "vv"));
ctx.Handler.UseCookies = true;
ctx.Handler.UseDefaultCredentials = true;
if (Server.IsLocal) {
ctx.Handler.Proxy = new WebProxy ("ee");
ctx.Handler.UseProxy = true;
}
var request = new HttpRequestMessage (HttpMethod.Get, uri);
request.Version = HttpVersion.Version10;
request.Headers.Add ("Keep-Alive", "false");
var response = await ctx.Client.SendAsync (
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.StatusCode, Is.EqualTo (HttpStatusCode.OK), "#100");
ctx.Assert (await response.Content.ReadAsStringAsync (), Is.Empty, "#101");
}
public async Task CustomHeaders (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (CustomHeaders_Handler);
var request = new HttpRequestMessage (HttpMethod.Get, uri);
ctx.Expect (request.Headers.TryAddWithoutValidation ("aa", "vv"), Is.True, "#0");
var response = await ctx.Client.SendAsync (
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.StatusCode, Is.EqualTo (HttpStatusCode.OK), "#101");
ctx.Assert (await response.Content.ReadAsStringAsync (), Is.Empty, "#100");
var headers = response.Headers;
IEnumerable<string> values;
if (ctx.Expect (headers.TryGetValues ("rsp", out values), Is.True, "#102"))
ctx.Expect (values.First (), Is.EqualTo ("rrr"), "#102a");
if (ctx.Expect (headers.TryGetValues ("Transfer-Encoding", out values), Is.True, "#103")) {
// CFNetwork automatically combines all chunks.
if (ctx.IsDefaultHandler) {
ctx.Expect (values.First (), Is.EqualTo ("chunked"), "#103a");
ctx.Expect (headers.TransferEncodingChunked, Is.True, "#103b");
} else {
ctx.Expect (values.First (), Is.EqualTo ("Identity"), "#103c");
ctx.Expect (headers.TransferEncodingChunked, Is.Null, "#103d");
}
}
if (ctx.Expect (headers.TryGetValues ("Date", out values), Is.True, "#104")) {
ctx.Expect (values.Count (), Is.EqualTo (1), "#104b");
// .NET overwrites Date, Mono does not
if (!ctx.IsDefaultHandler)
ctx.Expect (headers.Date, Is.Not.Null, "#104c");
}
ctx.Expect (headers.Upgrade.First (), Is.EqualTo (new ProductHeaderValue ("vvvvaa")), "#105");
ctx.Expect (headers.CacheControl.Extensions.First ().Name, Is.EqualTo ("audio"), "#106");
ctx.Expect (headers.Location.OriginalString, Is.EqualTo ("w3.org"), "#107");
ctx.Expect (response.ReasonPhrase, Is.EqualTo ("test description"), "#110");
// FIXME: .NET also returns 1.1 - bug ?
if (ctx.IsDefaultHandler)
ctx.Expect (response.Version, Is.EqualTo (HttpVersion.Version11), "#111");
}
public async Task Content (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (ContentHandler);
var request = new HttpRequestMessage (HttpMethod.Get, uri);
ctx.Assert (request.Headers.TryAddWithoutValidation ("aa", "vv"), Is.True, "#0");
var response = await ctx.Client.SendAsync (
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.StatusCode, Is.EqualTo (HttpStatusCode.OK), "#101");
ctx.Expect (await response.Content.ReadAsStringAsync (), Is.EqualTo ("7K"), "#100");
var headers = response.Headers;
IEnumerable<string> values;
if (ctx.Expect (headers.TryGetValues ("Transfer-Encoding", out values), Is.True, "#102")) {
// CFNetwork automatically combines all chunks.
if (ctx.IsDefaultHandler) {
ctx.Expect (values.First (), Is.EqualTo ("chunked"), "#102a");
ctx.Expect (headers.TransferEncodingChunked, Is.True, "#102b");
} else {
ctx.Expect (values.First (), Is.EqualTo ("Identity"), "#102c");
ctx.Expect (headers.TransferEncodingChunked, Is.Null, "#102d");
}
}
}
public async Task GetStringNoResponse (HttpClientTestContext ctx)
{
var uri = Server.GetUri (NoResponseHandler);
await ctx.Client.GetStringAsync (uri).ConfigureAwait (false);
}
public async Task MaxResponseContentBufferSize (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = Server.GetUri (MaxResponseContentBufferSize_Handler);
ctx.Client.MaxResponseContentBufferSize = 1000;
var request = new HttpRequestMessage (HttpMethod.Get, uri);
var response = await ctx.Client.SendAsync (
request, HttpCompletionOption.ResponseHeadersRead,
cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
Server.CheckException (response);
ctx.Assert (response.StatusCode, Is.EqualTo (HttpStatusCode.OK), "#101");
var result = await response.Content.ReadAsStringAsync ();
ctx.Expect (result.Length, Is.EqualTo (MaxResponseContentBufferSize_size), "#100");
}
public async Task DigestAuthentication (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var config = ctx.GetConfiguration<WebDavConfiguration> ();
var uri = new Uri (config.Server);
var cache = new CredentialCache ();
cache.Add (uri, "Digest", new NetworkCredential (config.UserName, config.Password));
ctx.Handler.Credentials = cache;
var response = await ctx.Client.GetAsync (
uri, cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
ctx.Expect (response.IsSuccessStatusCode, Is.True, "#100");
}
public async Task DigestPreAuthentication (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var config = ctx.GetConfiguration<WebDavConfiguration> ();
var random = new Random ();
var text = random.Next ().ToString ("x");
var uri = new Uri (config.Server);
var cache = new CredentialCache ();
cache.Add (uri, "Basic", new NetworkCredential ("invalid", text));
cache.Add (uri, "Digest", new NetworkCredential (config.UserName, config.Password));
ctx.Handler.Credentials = cache;
ctx.Handler.PreAuthenticate = true;
var response = await ctx.Client.GetAsync (
uri, cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
ctx.Expect (response.IsSuccessStatusCode, Is.True, "#100");
var response2 = await ctx.Client.GetAsync (
uri, cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response2);
ctx.Expect (response2.IsSuccessStatusCode, Is.True, "#101");
}
public async Task PutAndDelete (HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
var uri = GetRandomUri ();
var content = new StringContent (Text);
var response = await ctx.Client.PutAsync (
uri, content, cancellationToken).ConfigureAwait (false);
ctx.AutoDispose (response);
ctx.Assert (response.IsSuccessStatusCode, Is.True, "#100");
var response2 = await ctx.Client.DeleteAsync (uri, cancellationToken);
ctx.AutoDispose (response2);
ctx.Assert (response2.IsSuccessStatusCode, Is.True, "#101");
var response3 = await ctx.Client.GetAsync (uri, cancellationToken);
ctx.AutoDispose (response3);
ctx.Assert (response3.StatusCode, Is.EqualTo (HttpStatusCode.NotFound), "#102");
}
public Task DigestAuthentication_Default(HttpClientTestContext ctx,
CancellationToken cancellationToken)
{
return(DigestAuthentication(ctx, cancellationToken));
}
