MonoRail/Castle.MonoRail.Framework.Tests/Controllers/ControllerTestCase.cs

   1 // Copyright 2004-2008 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.Framework.Tests.Controllers
  16 {
  17         using System;
  18         using Castle.MonoRail.Framework.Services;
  19         using Core;
  20         using Descriptors;
  21         using NUnit.Framework;
  22         using Test;
  23
  24         [TestFixture]
  25         public class ControllerTestCase
  26         {
  27                 private MockEngineContext engineContext;
  28                 private ViewEngineManagerStub viewEngStub;
  29                 private MockServices services;
  30                 private MockResponse response;
  31
  32                 [SetUp]
  33                 public void Init()
  34                 {
  35                         MockRequest request = new MockRequest();
  36                         response = new MockResponse();
  37                         services = new MockServices();
  38                         viewEngStub = new ViewEngineManagerStub();
  39                         services.ViewEngineManager = viewEngStub;
  40                         engineContext = new MockEngineContext(request, response, services, null);
  41                 }
  42
  43                 [Test]
  44                 public void ControllerCallsInitialize()
  45                 {
  46                         ControllerWithInitialize controller = new ControllerWithInitialize();
  47
  48                         ControllerContext context = new ControllerContext("controller", "", "action1", new ControllerMetaDescriptor());
  49
  50                         controller.Process(engineContext, context);
  51
  52                         Assert.IsTrue(controller.Initialized);
  53                 }
  54
  55                 [Test, ExpectedException(typeof(MonoRailException), "Could not find action named NonExistentAction on controller \\home")]
  56                 public void InvokingNonExistingActionResultsIn404()
  57                 {
  58                         ControllerAndViews controller = new ControllerAndViews();
  59
  60                         IControllerContext context = new DefaultControllerContextFactory().
  61                                 Create("", "home", "NonExistentAction", new ControllerMetaDescriptor());
  62
  63                         try
  64                         {
  65                                 controller.Process(engineContext, context);
  66                         }
  67                         catch(MonoRailException)
  68                         {
  69                                 Assert.AreEqual(404, response.StatusCode);
  70
  71                                 throw;
  72                         }
  73                 }
  74
  75                 [Test]
  76                 public void RendersViewByDefault()
  77                 {
  78                         ControllerAndViews controller = new ControllerAndViews();
  79
  80                         IControllerContext context = services.ControllerContextFactory.
  81                                 Create("", "home", "EmptyAction", new ControllerMetaDescriptor());
  82
  83                         controller.Process(engineContext, context);
  84
  85                         Assert.AreEqual(200, response.StatusCode);
  86                         Assert.AreEqual("OK", response.StatusDescription);
  87                         Assert.AreEqual("home\\EmptyAction", viewEngStub.TemplateRendered);
  88                 }
  89
  90                 [Test]
  91                 public void ControllerCanOverrideView()
  92                 {
  93                         ControllerAndViews controller = new ControllerAndViews();
  94
  95                         IControllerContext context = services.ControllerContextFactory.
  96                                 Create("", "home", "ActionWithViewOverride", new ControllerMetaDescriptor());
  97
  98                         controller.Process(engineContext, context);
  99
 100                         Assert.AreEqual(200, response.StatusCode);
 101                         Assert.AreEqual("OK", response.StatusDescription);
 102                         Assert.AreEqual("home\\SomethingElse", viewEngStub.TemplateRendered);
 103                 }
 104
 105                 [Test]
 106                 public void ControllerCanCancelView()
 107                 {
 108                         ControllerAndViews controller = new ControllerAndViews();
 109
 110                         IControllerContext context = services.ControllerContextFactory.
 111                                 Create("", "home", "CancelsTheView", new ControllerMetaDescriptor());
 112
 113                         controller.Process(engineContext, context);
 114
 115                         Assert.AreEqual(200, response.StatusCode);
 116                         Assert.AreEqual("OK", response.StatusDescription);
 117                         Assert.IsNull(viewEngStub.TemplateRendered);
 118                 }
 119
 120                 [Test]
 121                 public void DefaultActionIsRun_AttributeOnMethod()
 122                 {
 123                         ControllerWithDefMethodOnAction controller = new ControllerWithDefMethodOnAction();
 124
 125                         IControllerContext context = services.ControllerContextFactory.
 126                                 Create("", "home", "index", services.ControllerDescriptorProvider.BuildDescriptor(controller));
 127
 128                         controller.Process(engineContext, context);
 129
 130                         Assert.IsTrue(controller.DefExecuted);
 131                         Assert.AreEqual("home\\index", viewEngStub.TemplateRendered);
 132                         Assert.AreEqual(200, response.StatusCode);
 133                         Assert.AreEqual("OK", response.StatusDescription);
 134                 }
 135
 136                 [Test]
 137                 public void DefaultActionIsRun_AttributeOnClass()
 138                 {
 139                         ControllerWithDefaultActionAttribute controller = new ControllerWithDefaultActionAttribute();
 140
 141                         IControllerContext context = services.ControllerContextFactory.
 142                                 Create("", "home", "index", services.ControllerDescriptorProvider.BuildDescriptor(controller));
 143
 144                         controller.Process(engineContext, context);
 145
 146                         Assert.IsTrue(controller.DefExecuted);
 147                         Assert.AreEqual("home\\index", viewEngStub.TemplateRendered);
 148                         Assert.AreEqual(200, response.StatusCode);
 149                         Assert.AreEqual("OK", response.StatusDescription);
 150                 }
 151
 152                 [Test]
 153                 public void AllServiceInterfacesAreInvokedForAHelperSoItIsContextualized()
 154                 {
 155                         ControllerWithCustomHelper controller = new ControllerWithCustomHelper();
 156
 157                         IControllerContext context = services.ControllerContextFactory.
 158                                 Create("", "home", "index", services.ControllerDescriptorProvider.BuildDescriptor(controller));
 159
 160                         engineContext.CurrentController = controller;
 161                         engineContext.CurrentControllerContext = context;
 162
 163                         controller.Process(engineContext, context);
 164
 165                         MyCustomHelper helper = (MyCustomHelper) context.Helpers["MyCustomHelper"];
 166                         Assert.IsTrue(helper.Service1Invoked);
 167                         Assert.IsTrue(helper.Service2Invoked);
 168                         Assert.IsTrue(helper.SetContextInvoked);
 169                         Assert.IsTrue(helper.SetControllerInvoked);
 170                 }
 171
 172                 #region Controllers
 173
 174                 private class ControllerWithInitialize : Controller
 175                 {
 176                         private bool initialized;
 177
 178                         protected override void Initialize()
 179                         {
 180                                 initialized = true;
 181                         }
 182
 183                         public bool Initialized
 184                         {
 185                                 get { return initialized; }
 186                         }
 187
 188                         public void Action1()
 189                         {
 190                         }
 191                 }
 192
 193                 private class ControllerAndViews : Controller
 194                 {
 195                         public void EmptyAction()
 196                         {
 197                         }
 198
 199                         public void ActionWithViewOverride()
 200                         {
 201                                 RenderView("SomethingElse");
 202                         }
 203
 204                         public void CancelsTheView()
 205                         {
 206                                 CancelView();
 207                         }
 208                 }
 209
 210                 private class ControllerWithDefMethodOnAction : Controller
 211                 {
 212                         private bool defExecuted;
 213
 214                         public void EmptyAction()
 215                         {
 216                         }
 217
 218                         [DefaultAction]
 219                         public void Default()
 220                         {
 221                                 defExecuted = true;
 222                         }
 223
 224                         public bool DefExecuted
 225                         {
 226                                 get { return defExecuted; }
 227                         }
 228                 }
 229
 230                 [DefaultAction("Default")]
 231                 class ControllerWithDefaultActionAttribute : Controller
 232                 {
 233                         private bool defExecuted;
 234
 235                         public void Default()
 236                         {
 237                                 defExecuted = true;
 238                         }
 239
 240                         public bool DefExecuted
 241                         {
 242                                 get { return defExecuted; }
 243                         }
 244                 }
 245
 246                 [Helper(typeof(MyCustomHelper))]
 247                 class ControllerWithCustomHelper : Controller
 248                 {
 249                         public void Index()
 250                         {
 251                         }
 252                 }
 253
 254                 class MyCustomHelper : IContextAware, IControllerAware, IServiceEnabledComponent, IMRServiceEnabled
 255                 {
 256                         private bool setContextInvoked;
 257                         private bool setControllerInvoked;
 258                         private bool service1Invoked;
 259                         private bool service2Invoked;
 260
 261                         public bool SetContextInvoked
 262                         {
 263                                 get { return setContextInvoked; }
 264                         }
 265
 266                         public bool SetControllerInvoked
 267                         {
 268                                 get { return setControllerInvoked; }
 269                         }
 270
 271                         public bool Service1Invoked
 272                         {
 273                                 get { return service1Invoked; }
 274                         }
 275
 276                         public bool Service2Invoked
 277                         {
 278                                 get { return service2Invoked; }
 279                         }
 280
 281                         public void SetContext(IEngineContext context)
 282                         {
 283                                 setContextInvoked = true;
 284                                 Assert.IsNotNull(context);
 285                         }
 286
 287                         public void SetController(IController controller, IControllerContext context)
 288                         {
 289                                 setControllerInvoked = true;
 290                                 Assert.IsNotNull(controller);
 291                                 Assert.IsNotNull(context);
 292                         }
 293
 294                         public void Service(IServiceProvider provider)
 295                         {
 296                                 service1Invoked = true;
 297                                 Assert.IsNotNull(provider);
 298                         }
 299
 300                         public void Service(IMonoRailServices serviceProvider)
 301                         {
 302                                 service2Invoked = true;
 303                                 Assert.IsNotNull(serviceProvider);
 304                         }
 305                 }
 306
 307                 #endregion
 308         }
 309 }