MonoRail/Castle.MonoRail.TestSupport/BaseControllerTest.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 Castle.Components.Common.EmailSender;
  20         using Castle.MonoRail.Framework.Test;
  21         using Framework;
  22
  23         public delegate void ContextInitializer(MockRailsEngineContext context);
  24
  25         /// <summary>
  26         /// Pendent
  27         /// </summary>
  28         public abstract class BaseControllerTest
  29         {
  30                 private readonly string domain;
  31                 private readonly string domainPrefix;
  32                 private readonly int port;
  33                 protected string virtualDir = "";
  34                 private MockRailsEngineContext context;
  35                 private IRequest request;
  36                 private IMockResponse response;
  37                 private ITrace trace;
  38
  39                 protected BaseControllerTest() : this("app.com", "www", 80)
  40                 {
  41                 }
  42
  43                 protected BaseControllerTest(string domain, string domainPrefix, int port)
  44                 {
  45                         this.domain = domain;
  46                         this.domainPrefix = domainPrefix;
  47                         this.port = port;
  48                 }
  49
  50                 protected IRailsEngineContext Context
  51                 {
  52                         get { return context; }
  53                 }
  54
  55                 public IRequest Request
  56                 {
  57                         get { return request; }
  58                 }
  59
  60                 public IMockResponse Response
  61                 {
  62                         get { return response; }
  63                 }
  64
  65                 public ITrace Trace
  66                 {
  67                         get { return trace; }
  68                 }
  69
  70                 protected void PrepareController(Controller controller)
  71                 {
  72                         PrepareController(controller, null);
  73                 }
  74
  75                 protected void PrepareController(Controller controller, ContextInitializer contextInitializer)
  76                 {
  77                         PrepareController(controller, "", "Controller", "Action");
  78                 }
  79
  80                 protected void PrepareController(Controller controller, string controllerName, string actionName)
  81                 {
  82                         PrepareController(controller, "", controllerName, actionName);
  83                 }
  84
  85                 protected void PrepareController(Controller controller, string areaName, string controllerName, string actionName)
  86                 {
  87                         if (controller == null)
  88                         {
  89                                 throw new ArgumentNullException("controller", "'controller' cannot be null");
  90                         }
  91                         if (areaName == null)
  92                         {
  93                                 throw new ArgumentNullException("areaName");
  94                         }
  95                         if (controllerName == null)
  96                         {
  97                                 throw new ArgumentNullException("controllerName");
  98                         }
  99                         if (actionName == null)
 100                         {
 101                                 throw new ArgumentNullException("actionName");
 102                         }
 103
 104                         BuildRailsContext(areaName, controllerName, actionName);
 105                         controller.InitializeFieldsFromServiceProvider(context);
 106                         controller.InitializeControllerState(areaName, controllerName, actionName);
 107                         ControllerLifecycleExecutor executor = new ControllerLifecycleExecutor(controller, context);
 108                         executor.Service(context);
 109                         executor.InitializeController(controller.AreaName, controller.Name, controller.Action);
 110                 }
 111
 112                 protected void BuildRailsContext(string areaName, string controllerName, string actionName)
 113                 {
 114                         UrlInfo info = BuildUrlInfo(areaName, controllerName, actionName);
 115                         request = BuildRequest();
 116                         response = BuildResponse();
 117                         trace = BuildTrace();
 118                         context = BuildRailsEngineContext(request, response, trace, info);
 119                 }
 120
 121                 protected virtual IRequest BuildRequest()
 122                 {
 123                         return new MockRequest();
 124                 }
 125
 126                 protected virtual IMockResponse BuildResponse()
 127                 {
 128                         return new MockResponse();
 129                 }
 130
 131                 protected virtual ITrace BuildTrace()
 132                 {
 133                         return new MockTrace();
 134                 }
 135
 136                 protected virtual MockRailsEngineContext BuildRailsEngineContext(IRequest request, IResponse response, ITrace trace,
 137                                                                                  UrlInfo urlInfo)
 138                 {
 139                         return new MockRailsEngineContext(request, response, trace, urlInfo);
 140                 }
 141
 142                 protected virtual UrlInfo BuildUrlInfo(string areaName, string controllerName, string actionName)
 143                 {
 144                         return new UrlInfo(domain, domainPrefix, virtualDir, "http", port,
 145                                            Path.Combine(Path.Combine(areaName, controllerName), actionName),
 146                                            areaName, controllerName, actionName, "rails");
 147                 }
 148
 149                 protected bool HasRenderedEmailTemplateNamed(string templateName)
 150                 {
 151                         MockRailsEngineContext.RenderedEmailTemplate template =
 152                                 context.RenderedEmailTemplates.Find(
 153                                         delegate(MockRailsEngineContext.RenderedEmailTemplate emailTemplate)
 154                                 {
 155                                         return templateName.Equals(emailTemplate.Name, StringComparison.OrdinalIgnoreCase);
 156                                 });
 157
 158                         return template != null;
 159                 }
 160
 161                 protected Message[] MessagesSent
 162                 {
 163                         get { return context.MessagesSent.ToArray(); }
 164                 }
 165
 166                 protected MockRailsEngineContext.RenderedEmailTemplate[] RenderedEmailTemplates
 167                 {
 168                         get { return context.RenderedEmailTemplates.ToArray(); }
 169                 }
 170         }
 171 }