X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem%2FTest%2FSystem.Net%2FHttpWebRequestTest.cs;h=dfab0a31e6fa0059d046d0e34829c64f48912122;hb=2fc81bb034cd9641544edf0758b63b29074b5213;hp=aa5b32845ad63f99094fa0881bde7077934ce8c6;hpb=6110fc90713ce59ff0996fcd3520e09a96575820;p=mono.git diff --git a/mcs/class/System/Test/System.Net/HttpWebRequestTest.cs b/mcs/class/System/Test/System.Net/HttpWebRequestTest.cs index aa5b32845ad..dfab0a31e6f 100644 --- a/mcs/class/System/Test/System.Net/HttpWebRequestTest.cs +++ b/mcs/class/System/Test/System.Net/HttpWebRequestTest.cs @@ -13,6 +13,8 @@ using NUnit.Framework; using System; using System.Collections; +using System.Collections.Specialized; +using System.Globalization; using System.IO; using System.Net; using System.Net.Sockets; @@ -20,9 +22,10 @@ using System.Security.Cryptography; using System.Security.Cryptography.X509Certificates; using System.Text; using System.Threading; - +#if !TARGET_JVM using Mono.Security.Authenticode; using Mono.Security.Protocol.Tls; +#endif namespace MonoTests.System.Net { @@ -30,28 +33,55 @@ namespace MonoTests.System.Net public class HttpWebRequestTest { [Test] - [Category("InetAccess")] +#if TARGET_JVM + [Ignore ("Ignore failures in Sys.Net")] +#endif + public void Proxy_Null () + { + HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com"); + Assert.IsNotNull (req.Proxy, "#1"); +#if NET_2_0 + req.Proxy = null; + Assert.IsNull (req.Proxy, "#2"); +#else + try { + req.Proxy = null; + Assert.Fail ("#2"); + } catch (ArgumentNullException ex) { + Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#3"); + Assert.IsNull (ex.InnerException, "#4"); + Assert.IsNotNull (ex.Message, "#5"); + Assert.IsNotNull (ex.ParamName, "#6"); + Assert.AreEqual ("value", ex.ParamName, "#7"); + } +#endif + } + + [Test] + [Category("InetAccess")] +#if TARGET_JVM + [Ignore ("NMA - wrong cookies number returned")] +#endif public void Sync () { HttpWebRequest req = (HttpWebRequest) WebRequest.Create ("http://www.google.com"); Assertion.AssertNotNull ("req:If Modified Since: ", req.IfModifiedSince); req.UserAgent = "MonoClient v1.0"; - Assertion.AssertEquals ("req Header 1", "User-Agent", req.Headers.GetKey (0)); - Assertion.AssertEquals ("req Header 2", "MonoClient v1.0", req.Headers.Get (0)); + Assert.AreEqual ("User-Agent", req.Headers.GetKey (0), "#A1"); + Assert.AreEqual ("MonoClient v1.0", req.Headers.Get (0), "#A2"); HttpWebResponse res = (HttpWebResponse) req.GetResponse (); - Assertion.AssertEquals ("res:HttpStatusCode: ", "OK", res.StatusCode.ToString ()); - Assertion.AssertEquals ("res:HttpStatusDescription: ", "OK", res.StatusDescription); - - Assertion.AssertEquals ("res Header 1", "text/html", res.Headers.Get ("Content-Type")); - Assertion.AssertNotNull ("Last Modified: ", res.LastModified); - - Assertion.AssertEquals ("res:", 0, res.Cookies.Count); - + Assert.AreEqual ("OK", res.StatusCode.ToString (), "#B1"); + Assert.AreEqual ("OK", res.StatusDescription, "#B2"); + + Assert.AreEqual ("text/html; charset=ISO-8859-1", res.Headers.Get ("Content-Type"), "#C1"); + Assert.IsNotNull (res.LastModified, "#C2"); + Assert.AreEqual (0, res.Cookies.Count, "#C3"); + res.Close (); } - + [Test] public void AddRange () { @@ -67,8 +97,38 @@ namespace MonoTests.System.Net } catch (InvalidOperationException) {} } + [Test] // bug #471782 + public void CloseRequestStreamAfterReadingResponse () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + + byte [] data = new byte [128]; + req.ContentLength = data.Length; + + Stream rs = req.GetRequestStream (); + rs.Write (data, 0, data.Length); + rs.Flush (); + + HttpWebResponse response = (HttpWebResponse) req.GetResponse (); + response.Close (); + + rs.Close (); + + responder.Stop (); + } + } + [Test] - [Category("InetAccess")] + [Category("InetAccess")] public void Cookies1 () { // The purpose of this test is to ensure that the cookies we get from a request @@ -92,6 +152,7 @@ namespace MonoTests.System.Net } } +#if !TARGET_JVM //NotWorking [Test] public void SslClientBlock () { @@ -123,8 +184,11 @@ namespace MonoTests.System.Net ServicePointManager.CertificatePolicy = null; } } - +#endif [Test] +#if TARGET_JVM + [Category("NotWorking")] +#endif public void Missing_ContentEncoding () { ServicePointManager.CertificatePolicy = new AcceptAllPolicy (); @@ -147,6 +211,9 @@ namespace MonoTests.System.Net } [Test] +#if TARGET_JVM + [Category ("NotWorking")] +#endif public void BadServer_ChunkedClose () { // The server will send a chunked response without a 'last-chunked' mark @@ -175,6 +242,1040 @@ namespace MonoTests.System.Net Assertion.AssertEquals ("1234567890123456", x); } + [Test] + [Ignore ("This test asserts that our code violates RFC 2616")] + public void MethodCase () + { + ListDictionary methods = new ListDictionary (); +#if NET_2_0 + methods.Add ("post", "POST"); + methods.Add ("puT", "PUT"); +#else + methods.Add ("post", "post"); + methods.Add ("puT", "puT"); +#endif + methods.Add ("POST", "POST"); + methods.Add ("whatever", "whatever"); + methods.Add ("PUT", "PUT"); + + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/"; + + foreach (DictionaryEntry de in methods) { + SocketResponder responder = new SocketResponder (new IPEndPoint (IPAddress.Loopback, 8000), + new SocketRequestHandler (EchoRequestHandler)); + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = (string) de.Key; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + rs.Close (); + using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) { + StreamReader sr = new StreamReader (resp.GetResponseStream (), + Encoding.UTF8); + string line = sr.ReadLine (); + sr.Close (); + Assert.AreEqual (((string) de.Value) + " /test/ HTTP/1.1", + line, req.Method); + resp.Close (); + } + responder.Stop (); + } + } + + [Test] + public void BeginGetRequestStream_Body_NotAllowed () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest request; + + request = (HttpWebRequest) WebRequest.Create (url); + request.Method = "GET"; + + try { + request.BeginGetRequestStream (null, null); + Assert.Fail ("#A1"); + } catch (ProtocolViolationException ex) { + // Cannot send a content-body with this + // verb-type + Assert.IsNull (ex.InnerException, "#A2"); + Assert.IsNotNull (ex.Message, "#A3"); + } + + request = (HttpWebRequest) WebRequest.Create (url); + request.Method = "HEAD"; + + try { + request.BeginGetRequestStream (null, null); + Assert.Fail ("#B1"); + } catch (ProtocolViolationException ex) { + // Cannot send a content-body with this + // verb-type + Assert.IsNull (ex.InnerException, "#B2"); + Assert.IsNotNull (ex.Message, "#B3"); + } + } + } + + [Test] // bug #465613 + public void BeginGetRequestStream_NoBuffering () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8002); + string url = "http://" + IPAddress.Loopback.ToString () + ":8002/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest req; + Stream rs; + IAsyncResult ar; + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = false; + req.AllowWriteStreamBuffering = false; + + ar = req.BeginGetRequestStream (null, null); + rs = req.EndGetRequestStream (ar); + rs.Close (); + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = true; + req.AllowWriteStreamBuffering = false; + + try { + req.BeginGetRequestStream (null, null); + Assert.Fail ("#A1"); + } catch (ProtocolViolationException ex) { + // When performing a write operation with + // AllowWriteStreamBuffering set to false, + // you must either set ContentLength to a + // non-negative number or set SendChunked + // to true + Assert.IsNull (ex.InnerException, "#A2"); + Assert.IsNotNull (ex.Message, "#A3"); + } + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = true; + req.AllowWriteStreamBuffering = false; + req.ContentLength = 0; + + ar = req.BeginGetRequestStream (null, null); + rs = req.EndGetRequestStream (ar); + rs.Close (); + } + } + + [Test] // bug #508027 + public void BeginGetResponse () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8003); + string url = "http://" + IPAddress.Loopback.ToString () + ":8003/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest req; + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = false; + req.AllowWriteStreamBuffering = false; + req.BeginGetResponse (null, null); + req.Abort (); + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = true; + req.KeepAlive = false; + req.AllowWriteStreamBuffering = false; + req.BeginGetResponse (null, null); + req.Abort (); + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.ContentLength = 5; + req.SendChunked = false; + req.KeepAlive = false; + req.AllowWriteStreamBuffering = false; + req.BeginGetResponse (null, null); + req.Abort (); + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = true; + req.AllowWriteStreamBuffering = false; +#if NET_2_0 + req.BeginGetResponse (null, null); + req.Abort (); +#else + try { + req.BeginGetResponse (null, null); + } catch (ProtocolViolationException ex) { + // Either ContentLength must be set to a non-negative + // number, or SendChunked set to true in order to perform + // the write operation when AllowWriteStreamBuffering + // is disabled + Assert.IsNull (ex.InnerException, "#A2"); + Assert.IsNotNull (ex.Message, "#A3"); + } finally { + req.Abort (); + } +#endif + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = false; + req.AllowWriteStreamBuffering = false; + req.ContentLength = 5; + req.BeginGetResponse (null, null); + req.Abort (); + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.SendChunked = false; + req.KeepAlive = true; + req.AllowWriteStreamBuffering = false; + req.ContentLength = 5; + req.BeginGetResponse (null, null); + req.Abort (); + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "GET"; + req.SendChunked = true; +#if NET_2_0 + req.BeginGetResponse (null, null); + req.Abort (); +#else + try { + req.BeginGetResponse (null, null); + Assert.Fail ("#B1"); + } catch (ProtocolViolationException ex) { + // Content-Length cannot be set for a + // non-write operation + Assert.IsNull (ex.InnerException, "#B2"); + Assert.IsNotNull (ex.Message, "#B3"); + } finally { + req.Abort (); + } +#endif + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "GET"; + req.ContentLength = 5; +#if NET_2_0 + req.BeginGetResponse (null, null); + req.Abort (); +#else + try { + req.BeginGetResponse (null, null); + Assert.Fail ("#C1"); + } catch (ProtocolViolationException ex) { + // Content-Length cannot be set for a + // non-write operation + Assert.IsNull (ex.InnerException, "#C2"); + Assert.IsNotNull (ex.Message, "#C3"); + } finally { + req.Abort (); + } +#endif + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "GET"; + req.ContentLength = 0; +#if NET_2_0 + req.BeginGetResponse (null, null); + req.Abort (); +#else + try { + req.BeginGetResponse (null, null); + Assert.Fail ("#D1"); + } catch (ProtocolViolationException ex) { + // Content-Length cannot be set for a + // non-write operation + Assert.IsNull (ex.InnerException, "#D2"); + Assert.IsNotNull (ex.Message, "#D3"); + } finally { + req.Abort (); + } +#endif + } + } + + [Test] // bug #429200 + public void GetRequestStream () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + + Stream rs1 = req.GetRequestStream (); + Stream rs2 = req.GetRequestStream (); + + Assert.IsNotNull (rs1, "#1"); + Assert.AreSame (rs1, rs2, "#2"); + + rs1.Close (); + } + } + + [Test] // bug #510661 and #514996 + [Category ("NotWorking")] + public void GetRequestStream_Close_NotAllBytesWritten () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest req; + Stream rs; + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.ContentLength = 2; + rs = req.GetRequestStream (); + try { + rs.Close (); + Assert.Fail ("#A1"); + } catch (WebException ex) { + // The request was aborted: The request was canceled + Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2"); + Assert.IsNotNull (ex.Message, "#A3"); + Assert.IsNull (ex.Response, "#A4"); + Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#A5"); + + // Cannot close stream until all bytes are written + Exception inner = ex.InnerException; + Assert.IsNotNull (inner, "#A6"); + Assert.AreEqual (typeof (IOException), inner.GetType (), "#A7"); + Assert.IsNull (inner.InnerException, "#A8"); + Assert.IsNotNull (inner.Message, "#A9"); + } + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.ContentLength = 2; + rs = req.GetRequestStream (); + rs.WriteByte (0x0d); + try { + rs.Close (); + Assert.Fail ("#B1"); + } catch (WebException ex) { + // The request was aborted: The request was canceled + Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2"); + Assert.IsNotNull (ex.Message, "#B3"); + Assert.IsNull (ex.Response, "#B4"); + Assert.AreEqual (WebExceptionStatus.RequestCanceled, ex.Status, "#B5"); + + // Cannot close stream until all bytes are written + Exception inner = ex.InnerException; + Assert.IsNotNull (inner, "#B6"); + Assert.AreEqual (typeof (IOException), inner.GetType (), "#B7"); + Assert.IsNull (inner.InnerException, "#B8"); + Assert.IsNotNull (inner.Message, "#B9"); + } + + req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.ContentLength = 2; + rs = req.GetRequestStream (); + rs.WriteByte (0x0d); + rs.WriteByte (0x0d); + rs.Close (); + } + } + + [Test] // bug #510642 + [Category ("NotWorking")] + public void GetRequestStream_Write_Overflow () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8001); + string url = "http://" + IPAddress.Loopback.ToString () + ":8001/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (EchoRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.ProtocolVersion = HttpVersion.Version11; + req.Method = "POST"; + req.Timeout = 200; + req.ReadWriteTimeout = 100; + req.ContentLength = 2; + + Stream rs = req.GetRequestStream (); + + byte [] buffer = new byte [] { 0x2a, 0x2c, 0x1d }; + try { + rs.Write (buffer, 0, 3); + Assert.Fail ("#1"); + } catch (ProtocolViolationException ex) { + // Bytes to be written to the stream exceed + // Content-Length bytes size specified + Assert.IsNull (ex.InnerException, "#2"); + Assert.IsNotNull (ex.Message, "#3"); + } finally { + req.Abort (); + } + } + } + + [Test] + [Ignore ("This test asserts that our code violates RFC 2616")] + public void GetRequestStream_Body_NotAllowed () + { + string [] methods = new string [] { "GET", "HEAD", "CONNECT", + "get", "HeAd", "ConNect" }; + + foreach (string method in methods) { + HttpWebRequest req = (HttpWebRequest) WebRequest.Create ( + "http://localhost:8000"); + req.Method = method; + try { + req.GetRequestStream (); + Assert.Fail ("#1:" + method); + } catch (ProtocolViolationException ex) { + Assert.AreEqual (typeof (ProtocolViolationException), ex.GetType (), "#2:" + method); + Assert.IsNull (ex.InnerException, "#3:" + method); + Assert.IsNotNull (ex.Message, "#4:" + method); + } + } + } + + [Test] +#if TARGET_JVM + [Category("NotWorking")] +#endif + [Ignore ("This does not timeout any more. That's how MS works when reading small responses")] + public void ReadTimeout () + { + IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764); + string url = "http://" + localEP.ToString () + "/original/"; + + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.AllowAutoRedirect = false; + req.Timeout = 200; + req.ReadWriteTimeout = 100; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + rs.Close (); + using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) { + try { + Stream s = resp.GetResponseStream (); + s.ReadByte (); + Assert.Fail ("#1"); + } catch (WebException ex) { + Assert.AreEqual (typeof (WebException), ex.GetType (), "#2"); + Assert.IsNull (ex.InnerException, "#3"); + Assert.IsNull (ex.Response, "#4"); + Assert.AreEqual (WebExceptionStatus.Timeout, ex.Status, "#5"); + } + } + responder.Stop (); + } + } + + [Test] // bug #324300 +#if TARGET_JVM + [Category("NotWorking")] +#endif + public void AllowAutoRedirect () + { + IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764); + string url = "http://" + localEP.ToString () + "/original/"; + + // allow autoredirect + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + rs.Close (); + using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) { + StreamReader sr = new StreamReader (resp.GetResponseStream (), + Encoding.UTF8); + string body = sr.ReadToEnd (); + + Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#A1"); + Assert.AreEqual (resp.ResponseUri.ToString (), "http://" + + localEP.ToString () + "/moved/", "#A2"); + Assert.AreEqual ("GET", resp.Method, "#A3"); + Assert.AreEqual ("LOOKS OK", body, "#A4"); + } + responder.Stop (); + } + + // do not allow autoredirect + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.AllowAutoRedirect = false; + req.Timeout = 1000; + req.ReadWriteTimeout = 1000; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + rs.Close (); + using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) { + Assert.AreEqual (resp.StatusCode, HttpStatusCode.Found, "#B1"); + Assert.AreEqual (url, resp.ResponseUri.ToString (), "#B2"); + Assert.AreEqual ("POST", resp.Method, "#B3"); + } + responder.Stop (); + } + } + + [Test] // bug #324347 + [Category ("NotWorking")] + public void InternalServerError () + { + IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764); + string url = "http://" + localEP.ToString () + "/original/"; + + // POST + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (InternalErrorHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + rs.Close (); + + try { + req.GetResponse (); + Assert.Fail ("#A1"); + } catch (WebException ex) { + Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.IsNotNull (ex.Message, "#A4"); + Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#A5"); + + HttpWebResponse webResponse = ex.Response as HttpWebResponse; + Assert.IsNotNull (webResponse, "#A6"); + Assert.AreEqual ("POST", webResponse.Method, "#A7"); + webResponse.Close (); + } + + responder.Stop (); + } + + // GET + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (InternalErrorHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "GET"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + + try { + req.GetResponse (); + Assert.Fail ("#B1"); + } catch (WebException ex) { + Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#B4"); + + HttpWebResponse webResponse = ex.Response as HttpWebResponse; + Assert.IsNotNull (webResponse, "#B5"); + Assert.AreEqual ("GET", webResponse.Method, "#B6"); + webResponse.Close (); + } + + responder.Stop (); + } + } + + [Test] + [Category ("NotWorking")] // #B3 fails; we get a SocketException: An existing connection was forcibly closed by the remote host + public void NoContentLength () + { + IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764); + string url = "http://" + localEP.ToString () + "/original/"; + + // POST + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (NoContentLengthHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + rs.Close (); + + try { + req.GetResponse (); + Assert.Fail ("#A1"); + } catch (WebException ex) { +#if NET_2_0 + // The underlying connection was closed: + // An unexpected error occurred on a + // receive + Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2"); + Assert.IsNotNull (ex.InnerException, "#A3"); + Assert.AreEqual (WebExceptionStatus.ReceiveFailure, ex.Status, "#A4"); + Assert.AreEqual (typeof (IOException), ex.InnerException.GetType (), "#A5"); + + // Unable to read data from the transport connection: + // A connection attempt failed because the connected party + // did not properly respond after a period of time, or + // established connection failed because connected host has + // failed to respond + IOException ioe = (IOException) ex.InnerException; + Assert.IsNotNull (ioe.InnerException, "#A6"); + Assert.IsNotNull (ioe.Message, "#A7"); + Assert.AreEqual (typeof (SocketException), ioe.InnerException.GetType (), "#A8"); + + // An existing connection was forcibly + // closed by the remote host + SocketException soe = (SocketException) ioe.InnerException; + Assert.IsNull (soe.InnerException, "#A9"); + Assert.IsNotNull (soe.Message, "#A10"); + + HttpWebResponse webResponse = ex.Response as HttpWebResponse; + Assert.IsNull (webResponse, "#A11"); +#else + // The remote server returned an error: + // (500) Internal Server Error + Assert.AreEqual (typeof (WebException), ex.GetType (), "#A2"); + Assert.IsNull (ex.InnerException, "#A3"); + Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#A4"); + + HttpWebResponse webResponse = ex.Response as HttpWebResponse; + Assert.IsNotNull (webResponse, "#A5"); + Assert.AreEqual ("POST", webResponse.Method, "#A6"); + webResponse.Close (); +#endif + } + + responder.Stop (); + } + + // GET + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (NoContentLengthHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "GET"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + + try { + req.GetResponse (); + Assert.Fail ("#B1"); + } catch (WebException ex) { + // The remote server returned an error: + // (500) Internal Server Error + Assert.AreEqual (typeof (WebException), ex.GetType (), "#B2"); + Assert.IsNull (ex.InnerException, "#B3"); + Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#B4"); + + HttpWebResponse webResponse = ex.Response as HttpWebResponse; + Assert.IsNotNull (webResponse, "#B5"); + Assert.AreEqual ("GET", webResponse.Method, "#B6"); + webResponse.Close (); + } + + responder.Stop (); + } + } + + [Test] // bug #513087 + public void NonStandardVerb () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/moved/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (VerbEchoHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "WhatEver"; + req.KeepAlive = false; + req.Timeout = 20000; + req.ReadWriteTimeout = 20000; + + Stream rs = req.GetRequestStream (); + rs.Close (); + + using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) { + StreamReader sr = new StreamReader (resp.GetResponseStream (), + Encoding.UTF8); + string body = sr.ReadToEnd (); + + Assert.AreEqual (resp.StatusCode, HttpStatusCode.OK, "#1"); + Assert.AreEqual (resp.ResponseUri.ToString (), "http://" + + ep.ToString () + "/moved/", "#2"); + Assert.AreEqual ("WhatEver", resp.Method, "#3"); + Assert.AreEqual ("WhatEver", body, "#4"); + } + + responder.Stop (); + } + } + + [Test] + [Category ("NotWorking")] // Assert #2 fails + public void NotModiedSince () + { + IPEndPoint ep = new IPEndPoint (IPAddress.Loopback, 8000); + string url = "http://" + IPAddress.Loopback.ToString () + ":8000/test/"; + + using (SocketResponder responder = new SocketResponder (ep, new SocketRequestHandler (NotModifiedSinceHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "GET"; + req.KeepAlive = false; + req.Timeout = 20000; + req.ReadWriteTimeout = 20000; +#if NET_2_0 + req.Headers.Add (HttpRequestHeader.IfNoneMatch, "898bbr2347056cc2e096afc66e104653"); +#else + req.Headers.Add ("If-None-Match", "898bbr2347056cc2e096afc66e104653"); +#endif + req.IfModifiedSince = new DateTime (2010, 01, 04); + + DateTime start = DateTime.Now; + HttpWebResponse response = null; + + try { + req.GetResponse (); + Assert.Fail ("#1"); + } catch (WebException e) { + response = (HttpWebResponse) e.Response; + } + + Assert.IsNotNull (response, "#2"); + using (Stream stream = response.GetResponseStream ()) { + byte [] buffer = new byte [4096]; + int bytesRead = stream.Read (buffer, 0, buffer.Length); + Assert.AreEqual (0, bytesRead, "#3"); + } + + TimeSpan elapsed = DateTime.Now - start; + Assert.IsTrue (elapsed.TotalMilliseconds < 2000, "#4"); + + responder.Stop (); + } + } + +#if NET_2_0 + [Test] // bug #324182 +#if TARGET_JVM + [Category ("NotWorking")] +#endif + public void Stream_CanTimeout () + { + IPEndPoint localEP = new IPEndPoint (IPAddress.Loopback, 8764); + string url = "http://" + localEP.ToString () + "/original/"; + + // allow autoredirect + using (SocketResponder responder = new SocketResponder (localEP, new SocketRequestHandler (RedirectRequestHandler))) { + responder.Start (); + + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (url); + req.Method = "POST"; + req.Timeout = 2000; + req.ReadWriteTimeout = 2000; + req.KeepAlive = false; + Stream rs = req.GetRequestStream (); + Assert.IsTrue (rs.CanTimeout, "#1"); + rs.Close (); + using (HttpWebResponse resp = (HttpWebResponse) req.GetResponse ()) { + Stream os = resp.GetResponseStream (); + Assert.IsTrue (os.CanTimeout, "#2"); + os.Close (); + } + responder.Stop (); + } + } +#endif + + [Test] // bug #353495 + [Category ("NotWorking")] + public void LastModifiedKind () + { + const string reqURL = "http://coffeefaq.com/site/node/25"; + HttpWebRequest req = (HttpWebRequest) WebRequest.Create (reqURL); + HttpWebResponse resp = (HttpWebResponse) req.GetResponse (); + DateTime lastMod = resp.LastModified; + string rawLastMod = resp.Headers ["Last-Modified"]; + resp.Close (); + //Assert.AreEqual ("Tue, 15 Jan 2008 08:59:59 GMT", rawLastMod, "#1"); +#if NET_2_0 + Assert.AreEqual (DateTimeKind.Local, lastMod.Kind, "#2"); +#endif + req = (HttpWebRequest) WebRequest.Create (reqURL); + req.IfModifiedSince = lastMod; + try { + resp = (HttpWebResponse) req.GetResponse (); + resp.Close (); + Assert.Fail ("Should result in 304"); + } catch (WebException ex) { + Assert.AreEqual (WebExceptionStatus.ProtocolError, ex.Status, "#3"); + Assert.AreEqual (((HttpWebResponse) ex.Response).StatusCode, HttpStatusCode.NotModified, "#4"); + } + } + + static byte [] EchoRequestHandler (Socket socket) + { + MemoryStream ms = new MemoryStream (); + byte [] buffer = new byte [4096]; + int bytesReceived = socket.Receive (buffer); + while (bytesReceived > 0) { + ms.Write (buffer, 0, bytesReceived); + if (socket.Available > 0) { + bytesReceived = socket.Receive (buffer); + } else { + bytesReceived = 0; + } + } + ms.Flush (); + ms.Position = 0; + StreamReader sr = new StreamReader (ms, Encoding.UTF8); + string request = sr.ReadToEnd (); + + StringWriter sw = new StringWriter (); + sw.WriteLine ("HTTP/1.1 200 OK"); + sw.WriteLine ("Content-Type: text/xml"); + sw.WriteLine ("Content-Length: " + request.Length.ToString (CultureInfo.InvariantCulture)); + sw.WriteLine (); + sw.Write (request); + sw.Flush (); + + return Encoding.UTF8.GetBytes (sw.ToString ()); + } + + static byte [] RedirectRequestHandler (Socket socket) + { + MemoryStream ms = new MemoryStream (); + byte [] buffer = new byte [4096]; + int bytesReceived = socket.Receive (buffer); + while (bytesReceived > 0) { + ms.Write (buffer, 0, bytesReceived); + if (socket.Available > 0) { + bytesReceived = socket.Receive (buffer); + } else { + bytesReceived = 0; + } + } + ms.Flush (); + ms.Position = 0; + string statusLine = null; + using (StreamReader sr = new StreamReader (ms, Encoding.UTF8)) { + statusLine = sr.ReadLine (); + } + + StringWriter sw = new StringWriter (); + if (statusLine.StartsWith ("POST /original/")) { + sw.WriteLine ("HTTP/1.0 302 Found"); + sw.WriteLine ("Location: " + "http://" + IPAddress.Loopback.ToString () + ":8764/moved/"); + sw.WriteLine (); + sw.Flush (); + } else if (statusLine.StartsWith ("GET /moved/")) { + sw.WriteLine ("HTTP/1.0 200 OK"); + sw.WriteLine ("Content-Type: text/plain"); + sw.WriteLine ("Content-Length: 8"); + sw.WriteLine (); + sw.Write ("LOOKS OK"); + sw.Flush (); + } else { + sw.WriteLine ("HTTP/1.0 500 Too Lazy"); + sw.WriteLine (); + sw.Flush (); + } + + return Encoding.UTF8.GetBytes (sw.ToString ()); + } + + static byte [] InternalErrorHandler (Socket socket) + { + StringWriter sw = new StringWriter (); + sw.WriteLine ("HTTP/1.1 500 Too Lazy"); + sw.WriteLine ("Content-Length: 0"); + sw.WriteLine (); + sw.Flush (); + + return Encoding.UTF8.GetBytes (sw.ToString ()); + } + + static byte [] NoContentLengthHandler (Socket socket) + { + StringWriter sw = new StringWriter (); + sw.WriteLine ("HTTP/1.1 500 Too Lazy"); + sw.WriteLine (); + sw.Flush (); + + return Encoding.UTF8.GetBytes (sw.ToString ()); + } + + static byte [] NotModifiedSinceHandler (Socket socket) + { + StringWriter sw = new StringWriter (); + sw.WriteLine ("HTTP/1.1 304 Not Modified"); + sw.WriteLine ("Date: Fri, 06 Feb 2009 12:50:26 GMT"); + sw.WriteLine ("Server: Apache/2.2.6 (Debian) PHP/5.2.6-2+b1 with Suhosin-Patch mod_ssl/2.2.6 OpenSSL/0.9.8g"); + sw.WriteLine ("Not-Modified-Since: Sun, 08 Feb 2009 08:49:26 GMT"); + sw.WriteLine ("ETag: 898bbr2347056cc2e096afc66e104653"); + sw.WriteLine ("Connection: close"); + sw.WriteLine (); + sw.Flush (); + + return Encoding.UTF8.GetBytes (sw.ToString ()); + } + + static byte [] VerbEchoHandler (Socket socket) + { + MemoryStream ms = new MemoryStream (); + byte [] buffer = new byte [4096]; + int bytesReceived = socket.Receive (buffer); + while (bytesReceived > 0) { + ms.Write (buffer, 0, bytesReceived); + if (socket.Available > 0) { + bytesReceived = socket.Receive (buffer); + } else { + bytesReceived = 0; + } + } + ms.Flush (); + ms.Position = 0; + string statusLine = null; + using (StreamReader sr = new StreamReader (ms, Encoding.UTF8)) { + statusLine = sr.ReadLine (); + } + + string verb = "DEFAULT"; + if (statusLine != null) { + string [] parts = statusLine.Split (' '); + if (parts.Length > 0) + verb = parts [0]; + } + + StringWriter sw = new StringWriter (); + sw.WriteLine ("HTTP/1.1 200 OK"); + sw.WriteLine ("Content-Type: text/plain"); + sw.WriteLine ("Content-Length: " + verb.Length); + sw.WriteLine (); + sw.Write (verb); + sw.Flush (); + + return Encoding.UTF8.GetBytes (sw.ToString ()); + } + + [Test] + public void NtlmAuthentication () + { + NtlmServer server = new NtlmServer (); + server.Start (); + + string url = String.Format ("http://{0}:{1}/nothing.html", server.IPAddress, server.Port); + HttpWebRequest request = (HttpWebRequest) WebRequest.Create (url); + request.Timeout = 5000; + request.Credentials = new NetworkCredential ("user", "password", "domain"); + HttpWebResponse resp = (HttpWebResponse) request.GetResponse (); + string res = null; + using (StreamReader reader = new StreamReader (resp.GetResponseStream ())) { + res = reader.ReadToEnd (); + } + resp.Close (); + server.Stop (); + Assert.AreEqual ("OK", res); + } + + class NtlmServer : HttpServer { + public string Where = ""; + protected override void Run () + { + Where = "before accept"; + Socket client = sock.Accept (); + NetworkStream ns = new NetworkStream (client, false); + StreamReader reader = new StreamReader (ns, Encoding.ASCII); + string line; + Where = "first read"; + while ((line = reader.ReadLine ()) != null) { + if (line.Trim () == String.Empty) { + break; + } + } + Where = "first write"; + StreamWriter writer = new StreamWriter (ns, Encoding.ASCII); + writer.Write ( "HTTP/1.1 401 Unauthorized\r\n" + + "WWW-Authenticate: NTLM\r\n" + + "Content-Length: 5\r\n\r\nWRONG"); + + writer.Flush (); + Where = "second read"; + while ((line = reader.ReadLine ()) != null) { + if (line.Trim () == String.Empty) { + break; + } + } + Where = "second write"; + writer.Write ( "HTTP/1.1 401 Unauthorized\r\n" + + "WWW-Authenticate: NTLM TlRMTVNTUAACAAAAAAAAADgAAAABggAC8GDhqIONH3sAAAAAAAAAAAAAAAA4AAAABQLODgAAAA8=\r\n" + + "Content-Length: 5\r\n\r\nWRONG"); + writer.Flush (); + + Where = "third read"; + while ((line = reader.ReadLine ()) != null) { + if (line.Trim () == String.Empty) { + break; + } + } + Where = "third write"; + writer.Write ( "HTTP/1.1 200 OK\r\n" + + "Keep-Alive: true\r\n" + + "Content-Length: 2\r\n\r\nOK"); + writer.Flush (); + Thread.Sleep (1000); + writer.Close (); + reader.Close (); + client.Close (); + } + } + class BadChunkedServer : HttpServer { protected override void Run () { @@ -243,6 +1344,7 @@ namespace MonoTests.System.Net protected abstract void Run (); } +#if !TARGET_JVM class SslHttpServer : HttpServer { X509Certificate _certificate; @@ -375,6 +1477,6 @@ namespace MonoTests.System.Net 238, 60, 227, 77, 217, 93, 117, 122, 111, 46, 173, 113, }; } +#endif } } -