mcs/class/System/Test/System.Net/CookieParserTest.cs

   1 using System;
   2 using System.IO;
   3 using System.Threading;
   4 using System.Globalization;
   5 using System.Net;
   6 using System.Net.Sockets;
   7 using NUnit.Framework;
   8
   9 namespace MonoTests.System.Net
  10 {
  11         [TestFixture]
  12         public class CookieParserTest
  13         {
  14                 public const string A = "Foo=Bar, expires=World; expires=Sat, 11-Oct-14 22:45:19 GMT, A=B";
  15                 public const string B = "A=B=C, expires=Sat, 99-Dec-01 01:00:00 XDT; Hello=World, Foo=Bar";
  16                 // Only the invariant culture is allowed.
  17                 public const string C = "Foo=Bar, expires=Montag, 21. Juni 2012 23:11:45";
  18                 // Only comma serves as separation character.
  19                 public const string D = "A=B, C=D; E=F, G=H";
  20                 public const string E = "A; C; expires=Tue, 25-Jun-19 00:51:34 GMT, E=F";
  21
  22                 CookieCollection DoRequest (string header)
  23                 {
  24                         HttpWebResponse res;
  25                         using (var listener = new Listener ("Set-Cookie: " + header)) {
  26                                 var req = (HttpWebRequest)HttpWebRequest.Create (listener.URI);
  27                                 req.CookieContainer = new CookieContainer ();
  28                                 req.Method = "POST";
  29                                 res = (HttpWebResponse)req.GetResponse ();
  30                         }
  31
  32                         Assert.AreEqual (header, res.Headers.Get ("Set-Cookie"));
  33                         return res.Cookies;
  34                 }
  35
  36                 void AssertCookie (Cookie cookie, string name, string value, long ticks)
  37                 {
  38                         AssertCookie (cookie, name, value);
  39                         Assert.AreEqual (ticks, cookie.Expires.ToUniversalTime ().Ticks);
  40                 }
  41
  42                 void AssertCookie (Cookie cookie, string name, string value)
  43                 {
  44                         Assert.AreEqual (name, cookie.Name);
  45                         Assert.AreEqual (value, cookie.Value);
  46                 }
  47
  48                 [Test]
  49                 public void TestDate ()
  50                 {
  51                         var d1 = "Sat, 11-Oct-14 22:45:19 GMT";
  52                         var d2 = "Tue, 25-Jun-19 00:51:34 GMT";
  53
  54                         var format = "ddd, dd'-'MMM'-'yy HH':'mm':'ss 'GMT'";
  55                         var p1 = DateTime.ParseExact (d1, format, CultureInfo.InvariantCulture);
  56                         p1 = DateTime.SpecifyKind (p1, DateTimeKind.Utc);
  57
  58                         Assert.AreEqual ("10/11/2014 22:45:19", p1.ToString ("G", CultureInfo.InvariantCulture));
  59                         Assert.AreEqual (p1.Ticks, p1.ToUniversalTime ().Ticks);
  60                         Assert.AreEqual (635486643190000000, p1.Ticks);
  61
  62                         var p2 = DateTime.ParseExact (d2, format, CultureInfo.InvariantCulture);
  63                         p2 = DateTime.SpecifyKind (p2, DateTimeKind.Utc);
  64                         Assert.AreEqual ("06/25/2019 00:51:34", p2.ToString ("G", CultureInfo.InvariantCulture));
  65                         Assert.AreEqual (p2.Ticks, p2.ToUniversalTime ().Ticks);
  66                         Assert.AreEqual (636970206940000000, p2.Ticks);
  67                 }
  68
  69                 [Test]
  70                 public void TestExpires ()
  71                 {
  72                         var cookies = DoRequest (A);
  73                         Assert.AreEqual (3, cookies.Count);
  74                         AssertCookie (cookies [0], "Foo", "Bar", 0);
  75                         AssertCookie (cookies [1], "expires", "World", 635486643190000000);
  76                         AssertCookie (cookies [2], "A", "B", 0);
  77                 }
  78
  79                 [Test]
  80                 public void TestInvalidCookie ()
  81                 {
  82                         var cookies = DoRequest (B);
  83                         Assert.AreEqual (3, cookies.Count);
  84                         AssertCookie (cookies [0], "A", "B=C");
  85                         AssertCookie (cookies [1], "expires", "Sat");
  86                         AssertCookie (cookies [2], "Foo", "Bar");
  87                 }
  88
  89                 [Test]
  90                 public void TestLocalCulture ()
  91                 {
  92                         var old = Thread.CurrentThread.CurrentCulture;
  93                         try {
  94                                 var culture = new CultureInfo ("de-DE");
  95                                 Thread.CurrentThread.CurrentCulture = culture;
  96
  97                                 var cookies = DoRequest (C);
  98                                 Assert.AreEqual (2, cookies.Count);
  99                                 AssertCookie (cookies [0], "Foo", "Bar");
 100                                 AssertCookie (cookies [1], "expires", "Montag");
 101                         } finally {
 102                                 Thread.CurrentThread.CurrentCulture = old;
 103                         }
 104                 }
 105
 106                 [Test]
 107                 public void TestMultiple ()
 108                 {
 109                         var cookies = DoRequest (D);
 110                         Assert.AreEqual (3, cookies.Count);
 111                         AssertCookie (cookies [0], "A", "B");
 112                         AssertCookie (cookies [1], "C", "D");
 113                         AssertCookie (cookies [2], "G", "H");
 114                 }
 115
 116                 [Test]
 117                 public void TestMultiple2 ()
 118                 {
 119                         var cookies = DoRequest (E);
 120                         Assert.AreEqual (2, cookies.Count);
 121                         AssertCookie (cookies [0], "A", string.Empty, 636970206940000000);
 122                         AssertCookie (cookies [1], "E", "F");
 123                 }
 124
 125                 public class Listener : IDisposable
 126                 {
 127                         Socket socket;
 128                         string[] headers;
 129
 130                         public Listener (params string[] headers)
 131                         {
 132                                 this.headers = headers;
 133                                 Start ();
 134                         }
 135
 136                         void Start ()
 137                         {
 138                                 socket = new Socket (
 139                                         AddressFamily.InterNetwork, SocketType.Stream,
 140                                         ProtocolType.Tcp);
 141                                 socket.Bind (new IPEndPoint (IPAddress.Loopback, 0));
 142                                 socket.Listen (1);
 143                                 socket.BeginAccept ((result) => {
 144                                         var accepted = socket.EndAccept (result);
 145                                         HandleRequest (accepted);
 146                                 }, null);
 147                         }
 148
 149                         public void Dispose ()
 150                         {
 151                                 if (socket != null) {
 152                                         socket.Close ();
 153                                         socket = null;
 154                                 }
 155                         }
 156
 157                         void HandleRequest (Socket accepted)
 158                         {
 159                                 using (var stream = new NetworkStream (accepted)) {
 160                                         using (var writer = new StreamWriter (stream)) {
 161                                                 writer.WriteLine ("HTTP/1.1 200 OK");
 162                                                 writer.WriteLine ("Content-Type: text/plain");
 163                                                 foreach (var header in headers)
 164                                                         writer.WriteLine (header);
 165                                                 writer.WriteLine ();
 166                                                 writer.WriteLine ("HELLO");
 167                                         }
 168                                 }
 169                         }
 170
 171                         public EndPoint EndPoint {
 172                                 get { return socket.LocalEndPoint; }
 173                         }
 174
 175                         public string URI {
 176                                 get { return string.Format ("http://{0}/", EndPoint); }
 177                         }
 178                 }
 179         }
 180 }