MonoRail/Castle.MonoRail.TestSupport/MonoRailTestWorkerRequest.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.Text;
  20         using System.Web.Hosting;
  21         using System.Collections;
  22         using System.Globalization;
  23
  24         /// <summary>
  25         /// Used to integrate with the ASP.Net Runtime
  26         /// </summary>
  27         public class MonoRailTestWorkerRequest : SimpleWorkerRequest
  28         {
  29                 private TextWriter output;
  30                 private TestRequest requestData;
  31                 private TestResponse response = new TestResponse();
  32                 private String virtualAppPath;
  33                 private String appPhysicalPath;
  34                 private String filePath;
  35                 private String[] knownRequestHeaders;
  36                 private String[][] unknownRequestHeaders;
  37                 private String queryString;
  38                 private byte[] preloadedContent;
  39                 private byte[] queryStringBytes;
  40                 private StringBuilder buffer = new StringBuilder();
  41
  42                 public MonoRailTestWorkerRequest(TestRequest requestData,
  43                                                  String virtualAppPath,
  44                                                  String physicalAppPath,
  45                                                  TextWriter output) : base(virtualAppPath, String.Empty, output)
  46                 {
  47                         this.virtualAppPath = virtualAppPath;
  48                         this.requestData = requestData;
  49                         this.appPhysicalPath = physicalAppPath;
  50                         this.output = output;
  51                         this.filePath = requestData.Url;
  52
  53                         if (!appPhysicalPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
  54                         {
  55                                 appPhysicalPath = appPhysicalPath + Path.DirectorySeparatorChar;
  56                         }
  57                 }
  58
  59                 protected internal void Prepare()
  60                 {
  61                         ProcessHeaders();
  62
  63                         ProcessQueryString();
  64
  65                         ProcessPostBody();
  66                 }
  67
  68                 private void ProcessHeaders()
  69                 {
  70                         knownRequestHeaders = new string[RequestHeaderMaximum];
  71
  72                         IList unknownHeaders = new ArrayList();
  73
  74                         foreach(String name in requestData.Headers)
  75                         {
  76                                 String value = requestData.Headers[name];
  77
  78                                 int index = GetKnownRequestHeaderIndex(name);
  79
  80                                 if (index >= 0)
  81                                 {
  82                                         knownRequestHeaders[index] = value;
  83                                 }
  84                                 else
  85                                 {
  86                                         unknownHeaders.Add(name);
  87                                         unknownHeaders.Add(value);
  88                                 }
  89                         }
  90
  91                         int totalunknownHeaders = unknownHeaders.Count / 2;
  92                         unknownRequestHeaders = new String[totalunknownHeaders][];
  93
  94                         int j = 0;
  95
  96                         for(int i = 0; i < totalunknownHeaders; i++)
  97                         {
  98                                 unknownRequestHeaders[i] = new String[2];
  99                                 unknownRequestHeaders[i][0] = (String) unknownHeaders[j++];
 100                                 unknownRequestHeaders[i][1] = (String) unknownHeaders[j++];
 101                         }
 102                 }
 103
 104                 private void ProcessQueryString()
 105                 {
 106                         if (requestData.QueryStringParams != null)
 107                         {
 108                                 buffer.Length = 0;
 109
 110                                 foreach(String param in requestData.QueryStringParams)
 111                                 {
 112                                         buffer.AppendFormat("{0}&", param);
 113                                 }
 114
 115                                 queryString = buffer.ToString();
 116
 117                                 queryStringBytes = Encoding.ASCII.GetBytes(queryString);
 118                         }
 119                 }
 120
 121                 private void ProcessPostBody()
 122                 {
 123                         if (requestData.PostParams != null)
 124                         {
 125                                 buffer.Length = 0;
 126
 127                                 foreach(String param in requestData.PostParams)
 128                                 {
 129                                         buffer.AppendFormat("{0}&", param);
 130                                 }
 131
 132                                 preloadedContent = Encoding.ASCII.GetBytes(buffer.ToString());
 133                         }
 134                 }
 135
 136                 public TestResponse Response
 137                 {
 138                         get { return response; }
 139                 }
 140
 141                 private string GetPathInternal()
 142                 {
 143                         return virtualAppPath.Equals("/")
 144                                 ? ("/" + filePath) : (virtualAppPath + "/" + filePath);
 145                 }
 146
 147                 public override string GetAppPath()
 148                 {
 149                         return virtualAppPath;
 150                 }
 151
 152                 public override string GetFilePathTranslated()
 153                 {
 154                         return appPhysicalPath + filePath.Replace('/', Path.DirectorySeparatorChar);
 155                 }
 156
 157                 public override String MapPath(String path)
 158                 {
 159                         String mappedPath;
 160
 161                         if (path == null || path.Length == 0 || path.Equals("/"))
 162                         {
 163                                 // asking for the site root
 164                                 if ("/".Equals(virtualAppPath))
 165                                 {
 166                                         // app at the site root
 167                                         mappedPath = appPhysicalPath;
 168                                 }
 169                                 else
 170                                 {
 171                                         // unknown site root - don't point to app root to avoid double config inclusion
 172                                         mappedPath = Environment.SystemDirectory;
 173                                 }
 174                         }
 175                         else
 176                         {
 177                                 if (path.StartsWith("/") || path.StartsWith("\\"))
 178                                 {
 179                                         path = path.Substring(1);
 180                                 }
 181
 182                                 mappedPath = new DirectoryInfo(Path.Combine(appPhysicalPath, path)).FullName;
 183                         }
 184
 185                         mappedPath = mappedPath.Replace('/', Path.DirectorySeparatorChar);
 186
 187                         if (mappedPath.EndsWith(Path.DirectorySeparatorChar.ToString()) && !mappedPath.EndsWith(":\\"))
 188                         {
 189                                 mappedPath = mappedPath.Substring(0, mappedPath.Length - 1);
 190                         }
 191
 192                         return mappedPath;
 193                 }
 194
 195                 public override String GetAppPathTranslated()
 196                 {
 197                         return appPhysicalPath;
 198                 }
 199
 200                 public override byte[] GetPreloadedEntityBody()
 201                 {
 202                         return preloadedContent;
 203                 }
 204
 205                 public override bool IsEntireEntityBodyIsPreloaded()
 206                 {
 207                         return true;
 208                 }
 209
 210                 public override int ReadEntityBody(byte[] buffer, int size)
 211                 {
 212                         int bytestocopy = Math.Min(preloadedContent.Length, size);
 213
 214                         Buffer.BlockCopy(preloadedContent, 0, buffer, 0, bytestocopy);
 215
 216                         return bytestocopy;
 217                 }
 218
 219                 public override String GetKnownRequestHeader(int index)
 220                 {
 221                         return knownRequestHeaders[index];
 222                 }
 223
 224                 public override String GetUnknownRequestHeader(String name)
 225                 {
 226                         for(int i = 0; i < unknownRequestHeaders.Length; i++)
 227                         {
 228                                 if (String.Compare(name, unknownRequestHeaders[i][0], true, CultureInfo.InvariantCulture) == 0)
 229                                 {
 230                                         return unknownRequestHeaders[i][1];
 231                                 }
 232                         }
 233
 234                         return null;
 235                 }
 236
 237                 public override String[][] GetUnknownRequestHeaders()
 238                 {
 239                         return unknownRequestHeaders;
 240                 }
 241
 242                 public override string GetServerVariable(string name)
 243                 {
 244                         String value = requestData.ServerVariables[name];
 245
 246                         if (value == null)
 247                         {
 248                                 switch(name)
 249                                 {
 250                                         case "SERVER_PROTOCOL":
 251                                                 return requestData.Protocol;
 252                                         case "QUERY_STRING":
 253                                                 return queryString;
 254                                 }
 255                         }
 256
 257                         return value == null ? String.Empty : value;
 258                 }
 259
 260                 public override void EndOfRequest()
 261                 {
 262                 }
 263
 264                 public override string GetFilePath()
 265                 {
 266                         return GetPathInternal();
 267                 }
 268
 269                 public override string GetHttpVerbName()
 270                 {
 271                         return requestData.Verb;
 272                 }
 273
 274                 public override string GetHttpVersion()
 275                 {
 276                         return requestData.Protocol;
 277                 }
 278
 279                 public override void FlushResponse(bool finalFlush)
 280                 {
 281                         response.Complete();
 282                 }
 283
 284                 public override string GetLocalAddress()
 285                 {
 286                         return requestData.LocalAddress;
 287                 }
 288
 289                 public override int GetLocalPort()
 290                 {
 291                         return requestData.LocalPort;
 292                 }
 293
 294                 public override String GetQueryString()
 295                 {
 296                         return queryString;
 297                 }
 298
 299                 public override byte[] GetQueryStringRawBytes()
 300                 {
 301                         return queryStringBytes;
 302                 }
 303
 304                 public override string GetRawUrl()
 305                 {
 306                         return String.Format("{0}{1}{2}",
 307                                              GetPathInternal(), queryString != null ? "?" : "", queryString);
 308                 }
 309
 310                 public override string GetRemoteAddress()
 311                 {
 312                         return requestData.RemoteAddress;
 313                 }
 314
 315                 public override int GetRemotePort()
 316                 {
 317                         return requestData.RemotePort;
 318                 }
 319
 320                 public override string GetUriPath()
 321                 {
 322                         return GetPathInternal();
 323                 }
 324
 325                 public override IntPtr GetUserToken()
 326                 {
 327                         return requestData.UserToken;
 328                 }
 329
 330                 public override void SendKnownResponseHeader(int index, string value)
 331                 {
 332                         String key = GetKnownResponseHeaderName(index);
 333
 334                         SendUnknownResponseHeader(key, value);
 335                 }
 336
 337                 public override void SendResponseFromFile(IntPtr handle, long offset, long length)
 338                 {
 339                         // TODO: SendResponseFromFile
 340                 }
 341
 342                 public override void SendResponseFromFile(string filename, long offset, long length)
 343                 {
 344                         // TODO: SendResponseFromFile
 345                 }
 346
 347                 public override void SendResponseFromMemory(byte[] data, int length)
 348                 {
 349                         output.Write(Encoding.Default.GetChars(data, 0, length));
 350                 }
 351
 352                 public override void SendStatus(int statusCode, string statusDescription)
 353                 {
 354                         response.StatusCode = statusCode;
 355                         response.StatusDescription = statusDescription;
 356                 }
 357
 358                 public override void SendUnknownResponseHeader(string name, string value)
 359                 {
 360                         object existingValue = response.Headers[name];
 361
 362                         if (existingValue == null)
 363                         {
 364                                 response.Headers[name] = value;
 365                         }
 366                         else
 367                         {
 368                                 if (existingValue is IList)
 369                                 {
 370                                         (existingValue as IList).Add(value);
 371                                 }
 372                                 else
 373                                 {
 374                                         IList list = new ArrayList();
 375
 376                                         list.Add(existingValue);
 377                                         list.Add(value);
 378
 379                                         response.Headers[name] = list;
 380                                 }
 381                         }
 382                 }
 383
 384                 public override bool IsSecure()
 385                 {
 386                         return false;
 387                 }
 388
 389                 public override string GetProtocol()
 390                 {
 391                         return requestData.Protocol;
 392                 }
 393
 394                 public override void SendCalculatedContentLength(int contentLength)
 395                 {
 396                         response.Headers["Content-Length"] = contentLength.ToString();
 397                 }
 398
 399                 public override bool HeadersSent()
 400                 {
 401                         return false;
 402                 }
 403
 404                 public override bool IsClientConnected()
 405                 {
 406                         return true;
 407                 }
 408
 409                 public override void CloseConnection()
 410                 {
 411                 }
 412         }
 413 }