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

   1 //
   2 // System.Net.CookieContainerTest - CookieContainer tests
   3 //
   4 // Authors:
   5 //      Gonzalo Paniagua Javier (gonzalo@novell.com)
   6 //      Daniel Nauck    (dna(at)mono-project(dot)de)
   7 //
   8 // (c) Copyright 2004 Novell, Inc. (http://www.novell.com)
   9 //
  10
  11 using System;
  12 using System.Net;
  13 using System.Reflection;
  14
  15 using NUnit.Framework;
  16
  17 namespace MonoTests.System.Net
  18 {
  19         [TestFixture]
  20         public class CookieContainerTest
  21         {
  22                 [Test]
  23                 public void TestCtor1 ()
  24                 {
  25                         CookieContainer c = new CookieContainer (234);
  26                         Assert.AreEqual (234, c.Capacity, "#1");
  27
  28                         try {
  29                                 new CookieContainer (0);
  30                                 Assert.Fail ("#2");
  31                         } catch (ArgumentException) {
  32                         }
  33
  34                         try {
  35                                 new CookieContainer (-10);
  36                                 Assert.Fail ("#3");
  37                         } catch (ArgumentException) {
  38                         }
  39                 }
  40
  41                 [Test]
  42                 public void TestCtor3 ()
  43                 {
  44                         CookieContainer c = new CookieContainer (100, 50, 1000);
  45                         Assert.AreEqual (100, c.Capacity, "#1");
  46                         Assert.AreEqual (50, c.PerDomainCapacity, "#2");
  47                         Assert.AreEqual (1000, c.MaxCookieSize, "#3");
  48
  49                         try {
  50                                 new CookieContainer (100, 0, 1000);
  51                                 Assert.Fail ("#4");
  52                         } catch (ArgumentException) {
  53                         }
  54
  55                         try {
  56                                 new CookieContainer (100, -1, 1000);
  57                                 Assert.Fail ("#5");
  58                         } catch (ArgumentException) {
  59                         }
  60
  61                         c = new CookieContainer (100, int.MaxValue, 1000);
  62                         Assert.AreEqual (int.MaxValue, c.PerDomainCapacity, "#6");
  63
  64                         try {
  65                                 new CookieContainer (100, 50, 0);
  66                                 Assert.Fail ("#7");
  67                         } catch (ArgumentException) {
  68                         }
  69
  70                         try {
  71                                 new CookieContainer (100, 500, -4);
  72                                 Assert.Fail ("#8");
  73                         } catch (ArgumentException) {
  74                         }
  75                 }
  76
  77                 [Test]
  78                 public void TestDefaultLimits ()
  79                 {
  80                         Assert.AreEqual (4096, CookieContainer.DefaultCookieLengthLimit, "#1");
  81                         Assert.AreEqual (300, CookieContainer.DefaultCookieLimit, "#2");
  82                         Assert.AreEqual (20, CookieContainer.DefaultPerDomainCookieLimit, "#3");
  83                 }
  84
  85                 [Test]
  86                 public void TestCapacity ()
  87                 {
  88                         CookieContainer c = new CookieContainer ();
  89                         Assert.AreEqual (300, c.Capacity, "#1");
  90                         c.Capacity = 200;
  91                         Assert.AreEqual (200, c.Capacity, "#2");
  92
  93                         try {
  94                                 c.Capacity = -5;
  95                                 Assert.Fail ("#3");
  96                         } catch (ArgumentOutOfRangeException) {
  97                         }
  98
  99                         try {
 100                                 c.Capacity = 5; // must be >= PerDomainCapacity if PerDomainCapacity != Int32.MaxValue
 101                                 Assert.Fail ("#4");
 102                         } catch (ArgumentOutOfRangeException) {
 103                         }
 104                 }
 105
 106                 [Test]
 107                 public void TestMaxCookieSize ()
 108                 {
 109                         CookieContainer c = new CookieContainer ();
 110                         Assert.AreEqual (4096, c.MaxCookieSize, "#1");
 111
 112                         try {
 113                                 c.MaxCookieSize = -5;
 114                                 Assert.Fail ("#2");
 115                         } catch (ArgumentOutOfRangeException) {
 116                         }
 117
 118                         try {
 119                                 c.MaxCookieSize = -1;
 120                                 Assert.Fail ("#3");
 121                         } catch (ArgumentOutOfRangeException) {
 122                         }
 123
 124                         c.MaxCookieSize = 80000;
 125                         Assert.AreEqual (80000, c.MaxCookieSize, "#4");
 126                         c.MaxCookieSize = int.MaxValue;
 127                         Assert.AreEqual (int.MaxValue, c.MaxCookieSize, "#5");
 128                 }
 129
 130                 [Test]
 131                 public void TestAdd_Args ()
 132                 {
 133                         CookieContainer cc = new CookieContainer ();
 134
 135                         try {
 136                                 cc.Add ((Cookie) null);
 137                                 Assert.Fail ("#1");
 138                         } catch (ArgumentNullException) {
 139                         }
 140
 141                         try {
 142                                 cc.Add ((CookieCollection) null);
 143                                 Assert.Fail ("#2");
 144                         } catch (ArgumentNullException) {
 145                         }
 146
 147                         try {
 148                                 cc.Add (null, (Cookie) null);
 149                                 Assert.Fail ("#3");
 150                         } catch (ArgumentNullException) {
 151                         }
 152
 153                         try {
 154                                 cc.Add (null, (CookieCollection) null);
 155                                 Assert.Fail ("#4");
 156                         } catch (ArgumentNullException) {
 157                         }
 158
 159                         try {
 160                                 cc.Add (new Uri ("http://www.contoso.com"), (Cookie) null);
 161                                 Assert.Fail ("#5");
 162                         } catch (ArgumentNullException) {
 163                         }
 164
 165                         try {
 166                                 cc.Add (new Uri ("http://www.contoso.com"), (CookieCollection) null);
 167                                 Assert.Fail ("#6");
 168                         } catch (ArgumentNullException) {
 169                         }
 170                 }
 171
 172                 [Test]
 173                 public void TestAdd_Cookie ()
 174                 {
 175                         CookieContainer cc = new CookieContainer ();
 176                         Uri uri = new Uri ("http://www.contoso.com");
 177                         cc.Add (uri, new CookieCollection ());
 178                         DateTime timestamp = DateTime.Now;
 179                         cc.Add (uri, new Cookie ("hola", "Adios"));
 180                         CookieCollection coll = cc.GetCookies (uri);
 181                         Cookie cookie = coll [0];
 182                         Assert.AreEqual ("", cookie.Comment, "#1");
 183                         Assert.IsNull (cookie.CommentUri, "#2");
 184                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#3");
 185                         Assert.IsFalse (cookie.Expired, "#4");
 186                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#5");
 187                         Assert.AreEqual ("hola", cookie.Name, "#6");
 188                         Assert.AreEqual ("/", cookie.Path, "#7");
 189                         Assert.AreEqual ("", cookie.Port, "#8");
 190                         Assert.IsFalse (cookie.Secure, "#9");
 191                         // FIX the next test
 192                         TimeSpan ts = cookie.TimeStamp - timestamp;
 193                         if (ts.TotalMilliseconds > 500)
 194                                 Assert.Fail ("#10");
 195
 196                         Assert.AreEqual ("Adios", cookie.Value, "#11");
 197                         Assert.AreEqual (0, cookie.Version, "#12");
 198                 }
 199
 200                 [Test]
 201                 [Category ("NotWorking")]
 202                 public void TestAddExpired_Cookie ()
 203                 {
 204                         CookieContainer cc = new CookieContainer ();
 205                         Uri uri = new Uri ("http://www.contoso.com");
 206                         DateTime expires = DateTime.Now.Subtract (new TimeSpan (1, 30, 0));
 207
 208                         //expired cookie
 209                         Cookie c1 = new Cookie ("TEST", "MyValue", "/", uri.Host);
 210                         c1.Expires = expires;
 211                         cc.Add (c1);
 212                         Assert.AreEqual (1, cc.Count, "#A1");
 213                         CookieCollection coll = cc.GetCookies (uri);
 214                         Assert.AreEqual (1, coll.Count, "#A1.1");
 215                         Cookie cookie = coll [0];
 216                         Assert.AreEqual ("", cookie.Comment, "#A2");
 217                         Assert.IsNull (cookie.CommentUri, "#A3");
 218                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#A4");
 219                         Assert.IsFalse (cookie.Expired, "#A5");
 220                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#A6");
 221                         Assert.AreEqual ("TEST", cookie.Name, "#A7");
 222                         Assert.AreEqual ("MyValue", cookie.Value, "#A8");
 223                         Assert.AreEqual ("/", cookie.Path, "#A9");
 224                         Assert.AreEqual ("", cookie.Port, "#A10");
 225                         Assert.IsFalse (cookie.Secure, "#A11");
 226
 227                         //expired cookie
 228                         Cookie c2 = new Cookie ("TEST2", "MyValue2");
 229                         c2.Expires = expires;
 230                         cc.Add (uri, c2);
 231                         Assert.AreEqual (1, cc.Count, "#B1");
 232                         coll = cc.GetCookies (uri);
 233                         Assert.AreEqual (1, coll.Count, "#B1.1");
 234                         cookie = coll [0];
 235                         Assert.AreEqual ("", cookie.Comment, "#B2");
 236                         Assert.IsNull (cookie.CommentUri, "#B3");
 237                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#B4");
 238                         Assert.IsFalse (cookie.Expired, "#B5");
 239                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#B6");
 240                         Assert.AreEqual ("TEST", cookie.Name, "#B7");
 241                         Assert.AreEqual ("MyValue", cookie.Value, "#B8");
 242                         Assert.AreEqual ("/", cookie.Path, "#B9");
 243                         Assert.AreEqual ("", cookie.Port, "#B10");
 244                         Assert.IsFalse (cookie.Secure, "#B11");
 245
 246                         //not expired cookie
 247                         Cookie c3 = new Cookie ("TEST3", "MyValue3");
 248                         cc.Add (uri, c3);
 249                         Assert.AreEqual (2, cc.Count, "#C1");
 250                         coll = cc.GetCookies (uri);
 251                         Assert.AreEqual (2, coll.Count, "#C1.1");
 252                         cookie = coll [1];
 253                         Assert.AreEqual ("", cookie.Comment, "#C2");
 254                         Assert.IsNull (cookie.CommentUri, "#C3");
 255                         Assert.AreEqual ("www.contoso.com", cookie.Domain, "#C4");
 256                         Assert.IsFalse (cookie.Expired, "#C5");
 257                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#C6");
 258                         Assert.AreEqual ("TEST3", cookie.Name, "#C7");
 259                         Assert.AreEqual ("MyValue3", cookie.Value, "#C8");
 260                         Assert.AreEqual ("/", cookie.Path, "#C9");
 261                         Assert.AreEqual ("", cookie.Port, "#C10");
 262                         Assert.IsFalse (cookie.Secure, "#C11");
 263
 264                         Assert.AreEqual (2, cc.Count, "#D1");
 265                         coll = cc.GetCookies (new Uri("http://contoso.com"));
 266                         Assert.AreEqual (0, coll.Count, "#D1.1");
 267
 268                         //not expired cookie
 269                         Cookie c4 = new Cookie ("TEST4", "MyValue4", "/", ".contoso.com");
 270                         cc.Add (uri, c4);
 271                         Assert.AreEqual (3, cc.Count, "#E1");
 272                         coll = cc.GetCookies (uri);
 273                         Assert.AreEqual (3, coll.Count, "#E1.1");
 274
 275                         //expired cookie
 276                         Cookie c5 = new Cookie ("TEST5", "MyValue5", "/", ".contoso.com");
 277                         c5.Expires = expires;
 278                         cc.Add (c5);
 279                         Assert.AreEqual (4, cc.Count, "#F1");
 280                         coll = cc.GetCookies (uri);
 281                         Assert.AreEqual (4, coll.Count, "#F1.1");
 282                         cookie = coll ["TEST5"];
 283                         Assert.AreEqual (".contoso.com", cookie.Domain, "#F2");
 284                         Assert.IsFalse (cookie.Expired, "#F3");
 285                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#F4");
 286                         Assert.AreEqual ("TEST5", cookie.Name, "#F5");
 287                         Assert.AreEqual ("MyValue5", cookie.Value, "#F6");
 288                         Assert.AreEqual ("/", cookie.Path, "#F7");
 289
 290                         //expired cookie
 291                         Cookie c6 = new Cookie ("TEST6", "MyValue6", "/", ".contoso.com");
 292                         c5.Expires = expires;
 293                         cc.Add (uri, c6);
 294                         Assert.AreEqual (5, cc.Count, "#G1");
 295                         coll = cc.GetCookies (uri);
 296                         Assert.AreEqual (5, coll.Count, "#G1.1");
 297                         cookie = coll ["TEST6"];
 298                         Assert.AreEqual (".contoso.com", cookie.Domain, "#G2");
 299                         Assert.IsFalse (cookie.Expired, "#G3");
 300                         Assert.AreEqual (DateTime.MinValue, cookie.Expires, "#G4");
 301                         Assert.AreEqual ("TEST6", cookie.Name, "#G5");
 302                         Assert.AreEqual ("MyValue6", cookie.Value, "#G6");
 303                         Assert.AreEqual ("/", cookie.Path, "#G7");
 304                 }
 305
 306                 [Test]
 307                 public void TestGetCookies_Args ()
 308                 {
 309                         CookieContainer cc = new CookieContainer ();
 310                         try {
 311                                 cc.GetCookies (null);
 312                                 Assert.Fail ("#1");
 313                         } catch (ArgumentNullException) {
 314                         }
 315                 }
 316
 317                 [Test]
 318                 public void TestSetCookies_Args ()
 319                 {
 320                         CookieContainer cc = new CookieContainer ();
 321                         try {
 322                                 cc.SetCookies (null, "");
 323                                 Assert.Fail ("#1");
 324                         } catch (ArgumentNullException) {
 325                         }
 326
 327                         try {
 328                                 cc.SetCookies (new Uri ("http://www.contoso.com"), null);
 329                                 Assert.Fail ("#2");
 330                         } catch (ArgumentNullException) {
 331                         }
 332
 333                         try {
 334                                 cc.SetCookies (new Uri ("http://www.contoso.com"), "=lalala");
 335                                 Assert.Fail ("#3");
 336                         } catch (CookieException) {
 337                         }
 338
 339                         cc.SetCookies (new Uri ("http://www.contoso.com"), "");
 340                 }
 341
 342                 [Test]
 343                 public void GetCookies ()
 344                 {
 345                         CookieContainer container = new CookieContainer ();
 346                         container.Add (new Cookie ("name", "value1", "/path", "localhost"));
 347                         container.Add (new Cookie ("name", "value2", "/path/sub", "localhost"));
 348
 349                         CookieCollection cookies = container.GetCookies (
 350                                 new Uri ("http://localhost/path/sub"));
 351                         Assert.IsNotNull (cookies, "#A1");
 352                         Assert.AreEqual (2, cookies.Count, "#A2");
 353
 354                         Cookie cookie = cookies [0];
 355                         Assert.AreEqual ("name", cookie.Name, "#B1");
 356                         Assert.AreEqual ("value2", cookie.Value, "#B2");
 357                         Assert.AreEqual ("/path/sub", cookie.Path, "#B3");
 358                         Assert.AreEqual ("localhost", cookie.Domain, "#B4");
 359
 360                         cookie = cookies [1];
 361                         Assert.AreEqual ("name", cookie.Name, "#C1");
 362                         Assert.AreEqual ("value1", cookie.Value, "#C2");
 363                         Assert.AreEqual ("/path", cookie.Path, "#C3");
 364                         Assert.AreEqual ("localhost", cookie.Domain, "#C4");
 365
 366                         cookies = container.GetCookies (new Uri ("http://localhost/path"));
 367                         Assert.IsNotNull (cookies, "#D1");
 368                         Assert.AreEqual (1, cookies.Count, "#D2");
 369
 370                         cookie = cookies [0];
 371                         Assert.AreEqual ("name", cookie.Name, "#E1");
 372                         Assert.AreEqual ("value1", cookie.Value, "#E2");
 373                         Assert.AreEqual ("/path", cookie.Path, "#E3");
 374                         Assert.AreEqual ("localhost", cookie.Domain, "#E4");
 375
 376                         cookies = container.GetCookies (new Uri ("http://localhost/whatever"));
 377                         Assert.IsNotNull (cookies, "#F1");
 378                         Assert.AreEqual (0, cookies.Count, "#F2");
 379                 }
 380
 381                 [Test]
 382                 [ExpectedException (typeof (ArgumentNullException))]
 383                 public void GetCookies_Uri_Null ()
 384                 {
 385                         CookieContainer container = new CookieContainer ();
 386                         container.GetCookies ((Uri) null);
 387                 }
 388         }
 389 }