MonoRail/Castle.MonoRail.TestSupport/AbstractMRTestCase.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MonoRail.TestSupport
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Net;
  20         using System.Text;
  21         using System.Text.RegularExpressions;
  22         using System.Web.Hosting;
  23         using System.Configuration;
  24         using System.Collections.Specialized;
  25         using System.Runtime.Serialization.Formatters.Binary;
  26         using System.Xml;
  27
  28         using NUnit.Framework;
  29
  30         /// <summary>
  31         /// Base class for tests cases using the ASP.Net Runtime
  32         /// to run the web project. Deprecated.
  33         /// </summary>
  34         [Obsolete("Prefer the BaseControllerTest")]
  35         public abstract class AbstractMRTestCase
  36         {
  37                 private static readonly String PhysicalWebDirConfigKey = "web.physical.dir";
  38                 private static readonly String VirtualWebDirConfigKey = "web.virtual.dir";
  39
  40                 private WebAppHost host;
  41                 private TestRequest request;
  42                 private TestResponse response;
  43                 private StringBuilder outputBuffer = new StringBuilder();
  44
  45                 #region Public Methods
  46
  47                 /// <summary>
  48                 /// Reinstates the request.
  49                 /// </summary>
  50                 /// <param name="serializedRequest">The serialized request.</param>
  51                 public void ReinstateRequest(byte[] serializedRequest)
  52                 {
  53                         BinaryFormatter bf;
  54                         MemoryStream ms = null;
  55                         try
  56                         {
  57                                 ms = new MemoryStream(serializedRequest);
  58                                 {
  59                                         bf = new BinaryFormatter();
  60                                         Request.Headers = (NameValueCollection) bf.Deserialize(ms);
  61                                 }
  62                         }
  63                         finally
  64                         {
  65                                 if (ms != null) ms.Close();
  66                         }
  67                 }
  68
  69                 /// <summary>
  70                 /// Gets the serialized request.
  71                 /// </summary>
  72                 /// <returns></returns>
  73                 public byte[] GetSerializedRequest()
  74                 {
  75                         MemoryStream objMS = new MemoryStream();
  76                         BinaryFormatter objBinaryFormatter = new BinaryFormatter();
  77
  78                         try
  79                         {
  80                                 objBinaryFormatter.Serialize(objMS, Request.Headers);
  81                         }
  82                         catch
  83                         {
  84                         }
  85
  86                         return objMS.GetBuffer();
  87                 }
  88
  89                 #endregion
  90
  91                 #region Test Lifecycle
  92
  93                 [TestFixtureSetUp]
  94                 public virtual void FixtureInitialize()
  95                 {
  96                         String virDir = GetVirtualDir();
  97                         String physicalDir = GetPhysicalDir();
  98
  99                         if (!Path.IsPathRooted(physicalDir))
 100                         {
 101                                 DirectoryInfo dinfo = new DirectoryInfo(
 102                                         Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, physicalDir));
 103
 104                                 physicalDir = dinfo.FullName;
 105                         }
 106
 107                         if (!Directory.Exists(Path.Combine(physicalDir, "bin")) ||
 108                             !File.Exists(Path.Combine(physicalDir, "web.config")))
 109                         {
 110                                 String message = String.Format("The path specified for the " +
 111                                                                "web project doesnt look as a web project dir (bin directory or web.config missing): {0}",
 112                                                                physicalDir);
 113                                 throw new ConfigurationErrorsException(message);
 114                         }
 115
 116                         host = (WebAppHost) ApplicationHost.CreateApplicationHost(
 117                                                 typeof(WebAppHost), virDir, physicalDir);
 118
 119                         host.Configure(virDir, physicalDir);
 120                 }
 121
 122                 [SetUp]
 123                 public virtual void Initialize()
 124                 {
 125                         request = new TestRequest();
 126                 }
 127
 128                 [TearDown]
 129                 public virtual void Terminate()
 130                 {
 131                 }
 132
 133                 [TestFixtureTearDown]
 134                 public virtual void FixtureTerminate()
 135                 {
 136                         if (host != null) host.Dispose();
 137                 }
 138
 139                 #endregion
 140
 141                 #region Actions
 142
 143                 /// <summary>
 144                 /// Performs a GET operation on the specified path.
 145                 /// </summary>
 146                 /// <example>
 147                 /// <code>
 148                 /// DoGet("home/index.rails");
 149                 /// </code>
 150                 /// </example>
 151                 /// <param name="path">The resource being request, for example <c>home/index.rails</c></param>
 152                 /// <param name="queryStringParams">A list of key/value pair, for example <c>name=johndoe</c></param>
 153                 public void DoGet(String path, params String[] queryStringParams)
 154                 {
 155                         DoGet(path, true, queryStringParams);
 156                 }
 157
 158                 /// <summary>
 159                 /// Performs a GET operation on the specified path.
 160                 /// </summary>
 161                 /// <example><code>
 162                 /// DoGet("home/index.rails");</code>
 163                 /// </example>
 164                 /// <param name="path">The resource being request, for example <c>home/index.rails</c></param>
 165                 /// <param name="resendCookies">if set to <c>true</c> [resend cookies].</param>
 166                 /// <param name="queryStringParams">A list of key/value pair, for example <c>name=johndoe</c></param>
 167                 public void DoGet(String path, bool resendCookies, params String[] queryStringParams)
 168                 {
 169                         AssertPathIsValid(path);
 170
 171                         if (queryStringParams.Length != 0)
 172                         {
 173                                 Request.QueryStringParams = queryStringParams;
 174                         }
 175                         else
 176                         {
 177                                 Request.QueryStringParams = null;
 178                         }
 179
 180                         if (resendCookies)
 181                         {
 182                                 ResendCookies();
 183                         }
 184
 185                         Request.Url = path;
 186                         Request.Verb = "GET";
 187                         Request.PostParams = null;
 188
 189                         SendRequest();
 190                 }
 191
 192                 /// <summary>
 193                 /// Performs a POST operation on the specified path.
 194                 /// </summary>
 195                 /// <example>
 196                 /// <code>
 197                 /// DoPost("producto/search.rails", "name=mac", "page=1");
 198                 /// </code>
 199                 /// </example>
 200                 /// <param name="path">The resource being request, for example <c>home/index.rails</c></param>
 201                 /// <param name="postStringParams">A list of key/value pair, for example <c>name=johndoe</c></param>
 202                 public void DoPost(String path, params String[] postStringParams)
 203                 {
 204                         DoPost(path, true, postStringParams);
 205                 }
 206
 207                 /// <summary>
 208                 /// Performs a POST operation on the specified path.
 209                 /// </summary>
 210                 /// <example>
 211                 /// <code>
 212                 /// DoPost("producto/search.rails", "name=mac", "page=1");
 213                 /// </code>
 214                 /// </example>
 215                 /// <param name="path">The resource being request, for example <c>home/index.rails</c></param>
 216                 /// <param name="resendCookies">if set to <c>true</c> [resend cookies].</param>
 217                 /// <param name="postStringParams">A list of key/value pair, for example <c>name=johndoe</c></param>
 218                 public void DoPost(String path, bool resendCookies, params String[] postStringParams)
 219                 {
 220                         if (postStringParams.Length != 0)
 221                         {
 222                                 Request.PostParams = postStringParams;
 223                         }
 224                         else
 225                         {
 226                                 Request.PostParams = null;
 227                         }
 228
 229                         outputBuffer.Length = 0;
 230
 231                         int pos = path.IndexOf('?');
 232
 233                         if (pos > -1)
 234                         {
 235                                 string qs = path.Substring(pos + 1);
 236                                 path = path.Substring(0, pos);
 237                                 Request.QueryStringParams = qs.Split('&');
 238                         }
 239                         else
 240                         {
 241                                 Request.QueryStringParams = null;
 242                         }
 243
 244                         // Set the content type so that the post data comes through.
 245                         Request.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
 246
 247                         Request.Url = path;
 248                         Request.Verb = "POST";
 249
 250                         if (resendCookies)
 251                         {
 252                                 ResendCookies();
 253                         }
 254
 255                         SendRequest();
 256                 }
 257
 258                 /// <summary>
 259                 /// Performs a HEAD operation on the specified path.
 260                 /// </summary>
 261                 /// <example>
 262                 /// <code>
 263                 /// DoHead("producto/search.rails", "name=mac", "page=1");
 264                 /// </code>
 265                 /// </example>
 266                 /// <param name="path">The resource being request, for example <c>home/index.rails</c></param>
 267                 /// <param name="postStringParams">A list of key/value pair, for example <c>name=johndoe</c></param>
 268                 public void DoHead(String path, params String[] postStringParams)
 269                 {
 270                         if (postStringParams.Length != 0)
 271                         {
 272                                 Request.PostParams = postStringParams;
 273                         }
 274                         else
 275                         {
 276                                 Request.PostParams = null;
 277                         }
 278
 279                         outputBuffer.Length = 0;
 280
 281                         int pos = path.IndexOf('?');
 282                         if (pos > -1)
 283                         {
 284                                 string qs = path.Substring(pos + 1);
 285                                 path = path.Substring(0, pos);
 286                                 Request.QueryStringParams = qs.Split('&');
 287                         }
 288                         else
 289                         {
 290                                 Request.QueryStringParams = null;
 291                         }
 292
 293                         Request.Url = path;
 294                         Request.Verb = "HEAD";
 295
 296                         SendRequest();
 297                 }
 298
 299                 #endregion
 300
 301                 #region Properties
 302
 303                 /// <summary>
 304                 /// Gets the <c>TestRequest</c>
 305                 /// </summary>
 306                 public TestRequest Request
 307                 {
 308                         get { return request; }
 309                 }
 310
 311                 /// <summary>
 312                 /// Gets the <c>TestResponse</c>
 313                 /// </summary>
 314                 public TestResponse Response
 315                 {
 316                         get { return response; }
 317                 }
 318
 319                 /// <summary>
 320                 /// Gets the request response
 321                 /// </summary>
 322                 public String Output
 323                 {
 324                         get { return outputBuffer.ToString(); }
 325                 }
 326
 327                 /// <summary>
 328                 /// Returns the sessionId related to the current session
 329                 /// </summary>
 330                 public string SessionId
 331                 {
 332                         get
 333                         {
 334                                 string sessionId = string.Empty;
 335
 336                                 try
 337                                 {
 338                                         sessionId =
 339                                                 Request.Cookies.GetCookies(new Uri("http://localhost"))["ASP.NET_SessionId"].ToString().Split("=".ToCharArray())[1
 340                                                         ];
 341                                 }
 342                                 catch
 343                                 {
 344                                 }
 345
 346                                 return sessionId;
 347                         }
 348                 }
 349
 350                 #endregion
 351
 352                 #region Available Asserts
 353
 354                 /// <summary>
 355                 /// Asserts that the response contains a number of nodes matching an XPath expression.
 356                 /// </summary>
 357                 /// <param name="xpathExpression">The xpath expression to match against.</param>
 358                 /// <param name="numberOfExpectedNodes">The number of expected nodes.</param>
 359                 protected void AssertResponseNodeCount(String xpathExpression, int numberOfExpectedNodes)
 360                 {
 361                         XmlDocument xml = new XmlDocument();
 362                         xml.LoadXml(Output);
 363
 364                         Assert.AreEqual(numberOfExpectedNodes, xml.SelectNodes(xpathExpression).Count);
 365                 }
 366
 367                 /// <summary>
 368                 /// Asserts that the response was NOT a redirect to the specified
 369                 /// <c>url</c> - for example check that your request was not sent to a login screen.
 370                 /// </summary>
 371                 protected void AssertNotRedirectedTo(String url)
 372                 {
 373                         // Location header always starts with a leading / so
 374                         // if this is not present on the specified url, add it
 375
 376                         if (url.IndexOf("/") != 0)
 377                         {
 378                                 url = "/" + url;
 379                         }
 380
 381                         Assert.IsFalse(url == (String) Response.Headers["Location"]);
 382                 }
 383
 384                 protected void AssertStatusCode(int expectedCode)
 385                 {
 386                         Assert.IsNotNull(response, "No requests performed with DoGet or DoPost (?)");
 387                         Assert.IsTrue(response.StatusCode == expectedCode, "Expecting status code {0} when it was in fact {1} {2}",
 388                                       expectedCode, response.StatusCode, response.StatusDescription);
 389                 }
 390
 391                 /// <summary>
 392                 /// Asserts the return status code is less than 400
 393                 /// </summary>
 394                 protected void AssertSuccess()
 395                 {
 396                         Assert.IsNotNull(response, "No requests performed with DoGet or DoPost (?)");
 397                         Assert.IsTrue(response.StatusCode < 400, "Expecting status code < 400 when it was in fact {0} - {1}",
 398                                       response.StatusCode, response.StatusDescription);
 399                 }
 400
 401                 /// <summary>
 402                 /// Asserts that reply has exactly the samme
 403                 /// content of <c>expectedContents</c>
 404                 /// </summary>
 405                 /// <param name="expectedContents"></param>
 406                 protected void AssertReplyEqualTo(String expectedContents)
 407                 {
 408                         Assert.AreEqual(expectedContents, Output, "Reply differs. Expecting {0} but was {1}", expectedContents, Output);
 409                 }
 410
 411                 /// <summary>
 412                 /// Asserts that reply starts with
 413                 /// <c>expectedContents</c>
 414                 /// </summary>
 415                 protected void AssertReplyStartsWith(String contents)
 416                 {
 417                         String buffer = Output;
 418
 419                         Assert.IsTrue(buffer.StartsWith(contents),
 420                                       String.Format("Reply string did not start with '{0}'. It was '{1}'", Prepare(contents),
 421                                                     Prepare(buffer.Substring(0, Math.Min(contents.Length, buffer.Length)))));
 422                 }
 423
 424                 /// <summary>
 425                 /// Asserts that reply ends with
 426                 /// <c>expectedContents</c>
 427                 /// </summary>
 428                 protected void AssertReplyEndsWith(String contents)
 429                 {
 430                         String buffer = Output;
 431
 432                         Assert.IsTrue(buffer.EndsWith(contents),
 433                                       "Reply string did not end with '{0}'. It was '{1}'", contents,
 434                                       buffer.Substring(0, Math.Min(contents.Length, buffer.Length)));
 435                 }
 436
 437                 /// <summary>
 438                 /// Asserts that reply contains the specified
 439                 /// <c>expectedContents</c>
 440                 /// </summary>
 441                 protected void AssertReplyContains(String contents)
 442                 {
 443                         Assert.IsTrue(Output.IndexOf(contents) != -1,
 444                                       "AssertReplyContains did not find the content '{0}'. Raw content '{1}'", contents, Output);
 445                 }
 446
 447                 /// <summary>
 448                 /// Asserts that reply have only whitespace characters
 449                 /// </summary>
 450                 protected void AssertReplyIsBlank()
 451                 {
 452                         string contents = Output.Trim();
 453
 454                         Assert.IsTrue(contents == String.Empty,
 455                                       "AssertReplyIsBlank found not whitespace characters '{0}'", contents);
 456                 }
 457
 458                 /// <summary>
 459                 /// Asserts that reply contents match the specified pattern, ignoring any whitespaces
 460                 /// <c>pattern</c>
 461                 /// </summary>
 462                 protected void AssertReplyMatch(String pattern)
 463                 {
 464                         AssertReplyMatch(pattern, true, RegexOptions.None);
 465                 }
 466
 467                 /// <summary>
 468                 /// Asserts that reply contents match the specified pattern
 469                 /// <c>pattern</c>
 470                 /// </summary>
 471                 protected void AssertReplyMatch(String pattern, bool ignoreSpaces)
 472                 {
 473                         AssertReplyMatch(pattern, ignoreSpaces, RegexOptions.None);
 474                 }
 475
 476                 /// <summary>
 477                 /// Asserts that reply contents match the specified pattern
 478                 /// <c>pattern</c>
 479                 /// </summary>
 480                 protected void AssertReplyMatch(String pattern, bool ignoreSpaces, RegexOptions options)
 481                 {
 482                         string contents = Output;
 483
 484                         if (ignoreSpaces)
 485                         {
 486                                 contents = Regex.Replace(contents, @"\s+", "");
 487                                 pattern = Regex.Replace(pattern, @"\s+", "");
 488                         }
 489
 490                         Regex re = new Regex(pattern, options);
 491
 492                         Assert.IsTrue(re.IsMatch(contents),
 493                                       "AssertReplyMatch did not match pattern '{0}'. Raw content {1}", pattern, contents);
 494                 }
 495
 496                 /// <summary>
 497                 /// Asserts that reply does not contain
 498                 /// <c>expectedContents</c>
 499                 /// </summary>
 500                 protected void AssertReplyDoesNotContain(String contents)
 501                 {
 502                         Assert.IsTrue(Output.IndexOf(contents) == -1,
 503                                       "AssertReplyDoNotContain found the content '{0}'", contents);
 504                 }
 505
 506                 /// <summary>
 507                 /// Asserts that the response was a redirect to the specified
 508                 /// <c>url</c>
 509                 /// </summary>
 510                 protected void AssertRedirectedTo(String url)
 511                 {
 512                         Assert.AreEqual(302, Response.StatusCode, "Redirect status not used");
 513                         AssertHasHeader("Location");
 514                         Assert.AreEqual(url, Response.Headers["Location"]);
 515                 }
 516
 517                 /// <summary>
 518                 /// Asserts that the content-type header is equals to the specified
 519                 /// value
 520                 /// </summary>
 521                 /// <param name="expectedContentType">value to assert to</param>
 522                 protected void AssertContentTypeEqualsTo(String expectedContentType)
 523                 {
 524                         AssertHasHeader("Content-Type");
 525                         Assert.AreEqual(expectedContentType, Response.Headers["Content-Type"]);
 526                 }
 527
 528                 /// <summary>
 529                 /// Asserts that the content-type header starts with to the specified
 530                 /// value
 531                 /// </summary>
 532                 /// <param name="expectedContentType">value to assert to</param>
 533                 protected void AssertContentTypeStartsWith(String expectedContentType)
 534                 {
 535                         AssertHasHeader("Content-Type");
 536                         Assert.IsTrue(Response.Headers["Content-Type"].ToString().StartsWith(expectedContentType));
 537                 }
 538
 539                 /// <summary>
 540                 /// Asserts that the content-type header ends with the specified
 541                 /// value
 542                 /// </summary>
 543                 /// <param name="expectedContentType">value to assert to</param>
 544                 protected void AssertContentTypeEndsWith(String expectedContentType)
 545                 {
 546                         AssertHasHeader("Content-Type");
 547                         Assert.IsTrue(Response.Headers["Content-Type"].ToString().EndsWith(expectedContentType));
 548                 }
 549
 550                 /// <summary>
 551                 /// Asserts that response contains the specified header.
 552                 /// </summary>
 553                 /// <param name="headerName">value to assert to</param>
 554                 protected void AssertHasHeader(String headerName)
 555                 {
 556                         Assert.IsTrue(Response.Headers[headerName] != null,
 557                                       "Header '{0}' was not found", headerName);
 558                 }
 559
 560                 /// <summary>
 561                 /// Asserts that PropertyBag contains the specified key.
 562                 /// </summary>
 563                 /// <param name="entryKey">key name</param>
 564                 protected void AssertPropertyBagContains(String entryKey)
 565                 {
 566                         Assert.IsNotNull(response.PropertyBag,
 567                                          "PropertyBag could not be used. Are you using a testing enable version of MonoRail Engine and Framework?");
 568                         Assert.IsTrue(response.PropertyBag.Contains(entryKey), "Entry {0} was not on PropertyBag", entryKey);
 569                 }
 570
 571                 /// <summary>
 572                 /// Asserts that PropertyBag's entry value equals to the specified value.
 573                 /// </summary>
 574                 /// <param name="entryKey">key name</param>
 575                 /// <param name="expectedValue">value to assert to</param>
 576                 protected void AssertPropertyBagEntryEquals(String entryKey, object expectedValue)
 577                 {
 578                         AssertPropertyBagContains(entryKey);
 579                         Assert.AreEqual(expectedValue, response.PropertyBag[entryKey], "PropertyBag entry differs from the expected");
 580                 }
 581
 582                 /// <summary>
 583                 /// Asserts that Flash contains the specified key.
 584                 /// </summary>
 585                 /// <param name="entryKey">key name</param>
 586                 protected void AssertFlashContains(String entryKey)
 587                 {
 588                         Assert.IsNotNull(response.Flash,
 589                                          "Flash could not be used. Are you using a testing enable version of MonoRail Engine and Framework?");
 590                         Assert.IsTrue(response.Flash.Contains(entryKey), "Entry {0} was not on Flash", entryKey);
 591                 }
 592
 593                 /// <summary>
 594                 /// Asserts that Flash does not contains the specified key.
 595                 /// </summary>
 596                 /// <param name="entryKey">key name</param>
 597                 protected void AssertFlashDoesNotContain(String entryKey)
 598                 {
 599                         Assert.IsNotNull(response.Flash,
 600                                          "Flash could not be used. Are you using a testing enable version of MonoRail Engine and Framework?");
 601                         Assert.IsFalse(response.Flash.Contains(entryKey), "Entry {0} was on Flash", entryKey);
 602                 }
 603
 604                 /// <summary>
 605                 /// Asserts that Flash's entry value equals to the specified value.
 606                 /// </summary>
 607                 /// <param name="entryKey">key name</param>
 608                 /// <param name="expectedValue">value to assert to</param>
 609                 protected void AssertFlashEntryEquals(String entryKey, object expectedValue)
 610                 {
 611                         AssertFlashContains(entryKey);
 612                         Assert.AreEqual(expectedValue, response.Flash[entryKey], "Flash entry differs from the expected");
 613                 }
 614
 615                 /// <summary>
 616                 /// Asserts that Session contains the specified key.
 617                 /// </summary>
 618                 /// <param name="entryKey">key name</param>
 619                 protected void AssertSessionContains(String entryKey)
 620                 {
 621                         Assert.IsNotNull(response.Session,
 622                                          "Session could not be used. Are you using a testing enable version of MonoRail Engine and Framework?");
 623                         Assert.IsTrue(response.Session.Contains(entryKey), "Entry {0} was not on Session", entryKey);
 624                 }
 625
 626                 /// <summary>
 627                 /// Asserts that Session does not contains the specified key.
 628                 /// </summary>
 629                 /// <param name="entryKey">key name</param>
 630                 protected void AssertSessionDoesNotContain(String entryKey)
 631                 {
 632                         Assert.IsNotNull(response.Session,
 633                                          "Session could not be used. Are you using a testing enable version of MonoRail Engine and Framework?");
 634                         Assert.IsFalse(response.Session.Contains(entryKey), "Entry {0} was on Session", entryKey);
 635                 }
 636
 637                 /// <summary>
 638                 /// Asserts that Session's entry value equals to the specified value.
 639                 /// </summary>
 640                 /// <param name="entryKey">key name</param>
 641                 /// <param name="expectedValue">value to assert to</param>
 642                 protected void AssertSessionEntryEqualsTo(String entryKey, object expectedValue)
 643                 {
 644                         AssertSessionContains(entryKey);
 645                         Assert.AreEqual(expectedValue, response.Session[entryKey], "Session entry differs from the expected");
 646                 }
 647
 648                 /// <summary>
 649                 /// Asserts that the response contains the specified cookie.
 650                 /// </summary>
 651                 /// <param name="cookieName">cookie name</param>
 652                 protected void AssertHasCookie(String cookieName)
 653                 {
 654                         CookieCollection cookies = Response.Cookies.GetCookies(new Uri("http://localhost"));
 655
 656                         foreach(Cookie cookie in cookies)
 657                         {
 658                                 if (cookie.Name.Equals(cookieName)) return;
 659                         }
 660
 661                         Assert.Fail("Cookie '{0}' was not found", cookieName);
 662                 }
 663
 664                 /// <summary>
 665                 /// Asserts that Response cookie entry value equals to the specified value.
 666                 /// </summary>
 667                 /// <param name="cookieName">cookie name</param>
 668                 /// <param name="expectedValue">value to assert to</param>
 669                 protected void AssertCookieValueEqualsTo(String cookieName, String expectedValue)
 670                 {
 671                         AssertHasCookie(cookieName);
 672
 673                         CookieCollection cookies = Response.Cookies.GetCookies(new Uri("http://localhost"));
 674
 675                         foreach(Cookie cookie in cookies)
 676                         {
 677                                 if (cookie.Name.Equals(cookieName))
 678                                 {
 679                                         Assert.AreEqual(expectedValue, cookie.Value);
 680                                         break;
 681                                 }
 682                         }
 683                 }
 684
 685                 /// <summary>
 686                 /// Asserts that the response cookie has the specified expiration.
 687                 /// </summary>
 688                 /// <param name="cookieName">cookie name</param>
 689                 /// <param name="expectedExpiration">value to assert to</param>
 690                 protected void AssertCookieExpirationEqualsTo(String cookieName, DateTime expectedExpiration)
 691                 {
 692                         AssertHasCookie(cookieName);
 693
 694                         CookieCollection cookies = Response.Cookies.GetCookies(new Uri("http://localhost"));
 695
 696                         foreach(Cookie cookie in cookies)
 697                         {
 698                                 if (cookie.Name.Equals(cookieName))
 699                                 {
 700                                         Assert.AreEqual(expectedExpiration.Day, cookie.Expires.Day, "Expiration day differs. Expecting {0} but was {1}",
 701                                                         expectedExpiration.Day, cookie.Expires.Day);
 702                                         Assert.AreEqual(expectedExpiration.Month, cookie.Expires.Month,
 703                                                         "Expiration month differs. Expecting {0} but was {1}", expectedExpiration.Month,
 704                                                         cookie.Expires.Month);
 705                                         Assert.AreEqual(expectedExpiration.Year, cookie.Expires.Year, "Expiration year differs. Expecting {0} but was {1}",
 706                                                         expectedExpiration.Year, cookie.Expires.Year);
 707                                         Assert.AreEqual(expectedExpiration.Hour, cookie.Expires.Hour, "Expiration hour differs. Expecting {0} but was {1}",
 708                                                         expectedExpiration.Hour, cookie.Expires.Hour);
 709                                         Assert.AreEqual(expectedExpiration.Minute, cookie.Expires.Minute,
 710                                                         "Expiration minute differs. Expecting {0} but was {1}", expectedExpiration.Minute,
 711                                                         cookie.Expires.Minute);
 712                                         // Assert.AreEqual(expectedExpiration.Second, cookie.Expires.Second, "Expiration second differs. Expecting {0} but was {1}", expectedExpiration.Second, cookie.Expires.Second);
 713                                         break;
 714                                 }
 715                         }
 716                 }
 717
 718                 #endregion
 719
 720                 #region Overridables
 721
 722                 protected virtual string GetPhysicalDir()
 723                 {
 724                         String dir = ConfigurationManager.AppSettings[PhysicalWebDirConfigKey];
 725
 726                         if (dir == null)
 727                         {
 728                                 String message = String.Format("Could not find a configuration key " +
 729                                                                "defining the web application physical directory. You must create " +
 730                                                                "a key ('{0}') on your configuration file or override the method " +
 731                                                                "AbstractMRTestCase.GetPhysicalDir", PhysicalWebDirConfigKey);
 732
 733                                 throw new ConfigurationErrorsException(message);
 734                         }
 735
 736                         return dir;
 737                 }
 738
 739                 protected virtual string GetVirtualDir()
 740                 {
 741                         String dir = ConfigurationManager.AppSettings[VirtualWebDirConfigKey];
 742
 743                         if (dir == null)
 744                         {
 745                                 dir = "/";
 746                         }
 747
 748                         return dir;
 749                 }
 750
 751                 #endregion
 752
 753                 private String Prepare(String content)
 754                 {
 755                         if (content == null || content.Length == 0) return String.Empty;
 756
 757                         return content.Replace("\n", "\\n").Replace("\r", "\\r").Replace("\t", "\\t");
 758                 }
 759
 760                 /// <summary>
 761                 /// Ensures that cookies (and therefore the session) will persist between requests,
 762                 /// emulating the behaviour of a genuine web client.
 763                 /// </summary>
 764                 private void ResendCookies()
 765                 {
 766                         // If no initial request has been made then there will be no response
 767                         // Therefore we do not need to resendcookies as none have been received
 768                         if (response != null)
 769                         {
 770                                 Uri uri = new Uri("http://localhost");
 771
 772                                 // We have a cookies container which is used to persist the cookies between requests,
 773                                 // emulating the cookie cache on a web browser
 774                                 //
 775                                 // Here we take the cookies from the response and append them to any existing cookies
 776                                 request.Cookies.Add(uri, response.Cookies.GetCookies(uri));
 777
 778                                 // Clear all of the cookie headers to prepare for them to be resent on the next request
 779                                 request.Headers.Remove("Cookie");
 780
 781                                 // Form a new cookie header from the cookies in the persistant request cookie container
 782                                 request.Headers.Add("Cookie", request.Cookies.GetCookieHeader(uri));
 783                         }
 784                 }
 785
 786                 private void SendRequest()
 787                 {
 788                         outputBuffer = new StringBuilder();
 789
 790                         StringWriter writer = new StringWriter(outputBuffer);
 791
 792                         if (Request.Headers["IsTestWorkerRequest"] == null)
 793                         {
 794                                 Request.Headers.Add("IsTestWorkerRequest", "true");
 795                         }
 796
 797                         response = host.Process(Request, writer);
 798
 799                         writer.Close();
 800                 }
 801
 802                 private void AssertPathIsValid(string path)
 803                 {
 804                         if (path == null)
 805                                 throw new ArgumentNullException("path", "Can't test a null path");
 806                         if (path.Length == 0)
 807                                 throw new ArgumentException("Can't test an empty path", "path");
 808                         if (path[0] == '/')
 809                                 throw new ArgumentException("Path cannot start with a '/'");
 810                 }
 811         }
 812 }