Merge pull request #2003 from esdrubal/seq_test_fix2

[mono.git] / mcs / class / System.Net.Http / Test / System.Net.Http / HttpClientTest.cs

diff --git a/mcs/class/System.Net.Http/Test/System.Net.Http/HttpClientTest.cs b/mcs/class/System.Net.Http/Test/System.Net.Http/HttpClientTest.cs
index eaeb6f6d23b965dad7c3b56087baf51ab3fc106c..ec049a932105ea973be9d262937694c89f83348e 100644 (file)
--- a/mcs/class/System.Net.Http/Test/System.Net.Http/HttpClientTest.cs
+++ b/mcs/class/System.Net.Http/Test/System.Net.Http/HttpClientTest.cs
@@ -83,6 +83,73 @@ namespace MonoTests.System.Net.Http
                        }
                }
 
+               class CustomStream : Stream
+               {
+                       public override void Flush ()
+                       {
+                               throw new NotImplementedException ();
+                       }
+
+                       int pos;
+
+                       public override int Read (byte[] buffer, int offset, int count)
+                       {
+                               ++pos;
+                               if (pos > 4)
+                                       return 0;
+
+                               return 11;
+                       }
+
+                       public override long Seek (long offset, SeekOrigin origin)
+                       {
+                               throw new NotImplementedException ();
+                       }
+
+                       public override void SetLength (long value)
+                       {
+                               throw new NotImplementedException ();
+                       }
+
+                       public override void Write (byte[] buffer, int offset, int count)
+                       {
+                               throw new NotImplementedException ();
+                       }
+
+                       public override bool CanRead {
+                               get {
+                                       return true;
+                               }
+                       }
+
+                       public override bool CanSeek {
+                               get {
+                                       return false;
+                               }
+                       }
+
+                       public override bool CanWrite {
+                               get {
+                                       throw new NotImplementedException ();
+                               }
+                       }
+
+                       public override long Length {
+                               get {
+                                       throw new NotImplementedException ();
+                               }
+                       }
+
+                       public override long Position {
+                               get {
+                                       throw new NotImplementedException ();
+                               }
+                               set {
+                                       throw new NotImplementedException ();
+                               }
+                       }
+               }
+
                const int WaitTimeout = 5000;
 
                string port, TestHost, LocalServer;
@@ -182,7 +249,7 @@ namespace MonoTests.System.Net.Http
 
                        var httpClient = new HttpClient (handler) {
                                BaseAddress = new Uri ("https://google.com"),
-                               Timeout = TimeSpan.FromSeconds (1)
+                               Timeout = TimeSpan.FromMilliseconds (1)
                        };
 
                        try {
@@ -248,6 +315,24 @@ namespace MonoTests.System.Net.Http
                        Assert.AreEqual (response, client.SendAsync (request).Result, "#1");
                }
 
+               [Test]
+               public void Send_BaseAddress ()
+               {
+                       var mh = new HttpMessageHandlerMock ();
+
+                       var client = new HttpClient (mh);
+                       client.BaseAddress = new Uri ("http://localhost/");
+                       var response = new HttpResponseMessage ();
+
+                       mh.OnSend = l => {
+                               Assert.AreEqual ("http://localhost/relative", l.RequestUri.ToString (), "#2");
+                               return Task.FromResult (response);
+                       };
+
+                       Assert.AreEqual (response, client.GetAsync ("relative").Result, "#1");
+                       Assert.AreEqual (response, client.GetAsync ("/relative").Result, "#2");
+               }
+
                [Test]
                public void Send_DefaultRequestHeaders ()
                {
@@ -487,6 +572,97 @@ namespace MonoTests.System.Net.Http
                        }
                }
 
+               [Test]
+               public void Send_Complete_CustomHeaders_SpecialSeparators ()
+               {
+                       bool? failed = null;
+
+                       var listener = CreateListener (l => {
+                               var request = l.Request;
+
+                               try {
+                                       Assert.AreEqual ("MLK Android Phone 1.1.9", request.UserAgent, "#1");
+                                       failed = false;
+                               } catch {
+                                       failed = true;
+                               }
+                       });
+
+                       try {
+                               var client = new HttpClient ();
+
+                               client.DefaultRequestHeaders.Add("User-Agent", "MLK Android Phone 1.1.9");
+
+                               var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+
+                               var response = client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Result;
+
+                               Assert.AreEqual ("", response.Content.ReadAsStringAsync ().Result, "#100");
+                               Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#101");
+                               Assert.AreEqual (false, failed, "#102");
+                       } finally {
+                               listener.Abort ();
+                               listener.Close ();
+                       }
+               }
+
+               [Test]
+               public void Send_Transfer_Encoding_Chunked ()
+               {
+                       bool? failed = null;
+
+                       var listener = CreateListener (l => {
+                               var request = l.Request;
+
+                               try {
+                                       Assert.AreEqual (1, request.Headers.Count, "#1");
+                                       failed = false;
+                               } catch {
+                                       failed = true;
+                               }
+                       });
+
+                       try {
+                               var client = new HttpClient ();
+                               client.DefaultRequestHeaders.TransferEncodingChunked = true;
+
+                               client.GetAsync (LocalServer).Wait ();
+
+                               Assert.AreEqual (false, failed, "#102");
+                       } finally {
+                               listener.Abort ();
+                               listener.Close ();
+                       }
+               }
+
+               [Test]
+               public void Send_Transfer_Encoding_Custom ()
+               {
+                       bool? failed = null;
+
+                       var listener = CreateListener (l => {
+                               failed = true;
+                       });
+
+                       try {
+                               var client = new HttpClient ();
+                               client.DefaultRequestHeaders.TransferEncoding.Add (new TransferCodingHeaderValue ("chunked2"));
+
+                               var request = new HttpRequestMessage (HttpMethod.Get, LocalServer);
+
+                               try {
+                                       client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Wait ();
+                                       Assert.Fail ("#1");
+                               } catch (AggregateException e) {
+                                       Assert.AreEqual (typeof (ProtocolViolationException), e.InnerException.GetType (), "#2");
+                               }
+                               Assert.IsNull (failed, "#102");
+                       } finally {
+                               listener.Abort ();
+                               listener.Close ();
+                       }
+               }
+
                [Test]
                public void Send_Complete_Content ()
                {
@@ -682,6 +858,31 @@ namespace MonoTests.System.Net.Http
                        }
                }
 
+               [Test]
+               public void Send_Content_Put_CustomStream ()
+               {
+                       bool passed = false;
+                       var listener = CreateListener (l => {
+                               var request = l.Request;
+                               passed = 44 == request.ContentLength64;
+                               passed &= request.ContentType == null;
+                       });
+
+                       try {
+                               var client = new HttpClient ();
+                               var r = new HttpRequestMessage (HttpMethod.Put, LocalServer);
+                               r.Content = new StreamContent (new CustomStream ());
+                               var response = client.SendAsync (r).Result;
+
+                               Assert.AreEqual (HttpStatusCode.OK, response.StatusCode, "#1");
+                               Assert.IsTrue (passed, "#2");
+                       } finally {
+                               listener.Abort ();
+
+                               listener.Close ();
+                       }
+               }
+
                [Test]
                public void Send_Timeout ()
                {
@@ -758,17 +959,6 @@ namespace MonoTests.System.Net.Http
                        }
                }
 
-               [Test]
-               public void GetString_RelativeUri ()
-               {
-                       var client = new HttpClient ();
-                       client.BaseAddress = new Uri ("http://en.wikipedia.org/wiki/");
-                       var uri = new Uri ("Computer", UriKind.Relative);
-
-                       Assert.That (client.GetStringAsync (uri).Result != null);
-                       Assert.That (client.GetStringAsync ("Computer").Result != null);
-               }
-
                [Test]
                [Category ("MobileNotWorking")] // Missing encoding
                public void GetString_Many ()
@@ -845,8 +1035,10 @@ namespace MonoTests.System.Net.Http
                                chandler.AllowAutoRedirect = true;
                                var client = new HttpClient (chandler);
 
-                               var resp = client.GetAsync (LocalServer).Result;
-                               Assert.AreEqual ("http://xamarin.com/", resp.RequestMessage.RequestUri.AbsoluteUri, "#1");
+                               var r = client.GetAsync (LocalServer);
+                               Assert.IsTrue (r.Wait (WaitTimeout), "#1");
+                               var resp = r.Result;
+                               Assert.AreEqual ("http://xamarin.com/", resp.RequestMessage.RequestUri.AbsoluteUri, "#2");
                        } finally {
                                listener.Abort ();
                                listener.Close ();