MonoRail/Castle.MonoRail.Framework.Tests/Filters/ControllerLevelFiltersTestCase.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.Filters
  16 {
  17         using NUnit.Framework;
  18         using Rhino.Mocks;
  19         using Test;
  20
  21         [TestFixture]
  22         public class ControllerLevelFiltersTestCase
  23         {
  24                 private MockRepository mockRepository = new MockRepository();
  25                 private MockEngineContext engineContext;
  26                 private ViewEngineManagerStub viewEngStub;
  27                 private MockServices services;
  28                 private IFilterFactory filterFactoryMock;
  29
  30                 [SetUp]
  31                 public void Init()
  32                 {
  33                         MockRequest request = new MockRequest();
  34                         MockResponse response = new MockResponse();
  35                         services = new MockServices();
  36                         viewEngStub = new ViewEngineManagerStub();
  37                         services.ViewEngineManager = viewEngStub;
  38                         filterFactoryMock = mockRepository.CreateMock<IFilterFactory>();
  39                         services.FilterFactory = filterFactoryMock;
  40                         engineContext = new MockEngineContext(request, response, services, null);
  41                 }
  42
  43                 [Test]
  44                 public void Filter_BeforeActionReturningFalsePreventsActionProcessment()
  45                 {
  46                         ControllerWithSingleBeforeActionFilter controller = new ControllerWithSingleBeforeActionFilter();
  47
  48                         IControllerContext context = services.ControllerContextFactory.
  49                                 Create("", "home", "index",
  50                                        services.ControllerDescriptorProvider.BuildDescriptor(controller));
  51
  52                         IFilter filterMock = mockRepository.CreateMock<IFilter>();
  53
  54                         using(mockRepository.Record())
  55                         {
  56                                 Expect.Call(filterFactoryMock.Create(typeof(DummyFilter))).Return(filterMock);
  57
  58                                 Expect.Call(filterMock.Perform(ExecuteWhen.BeforeAction, engineContext, controller, context)).Return(false);
  59
  60                                 filterFactoryMock.Release(filterMock);
  61                                 LastCall.Repeat.Once();
  62                         }
  63
  64                         using(mockRepository.Playback())
  65                         {
  66                                 controller.Process(engineContext, context);
  67                                 controller.Dispose();
  68
  69                                 Assert.IsNull(viewEngStub.TemplateRendered);
  70                                 Assert.IsFalse(controller.indexActionExecuted);
  71                         }
  72                 }
  73
  74                 [Test]
  75                 public void Filter_BeforeActionReturningTrueAllowsProcessToContinue()
  76                 {
  77                         ControllerWithSingleBeforeActionFilter controller = new ControllerWithSingleBeforeActionFilter();
  78
  79                         IControllerContext context = services.ControllerContextFactory.
  80                                 Create("", "home", "index",
  81                                        services.ControllerDescriptorProvider.BuildDescriptor(controller));
  82
  83                         IFilter filterMock = mockRepository.CreateMock<IFilter>();
  84
  85                         using(mockRepository.Record())
  86                         {
  87                                 Expect.Call(filterFactoryMock.Create(typeof(DummyFilter))).Return(filterMock);
  88
  89                                 Expect.Call(filterMock.Perform(ExecuteWhen.BeforeAction, engineContext, controller, context)).Return(true);
  90
  91                                 filterFactoryMock.Release(filterMock);
  92                                 LastCall.Repeat.Once();
  93                         }
  94
  95                         using(mockRepository.Playback())
  96                         {
  97                                 controller.Process(engineContext, context);
  98                                 controller.Dispose();
  99
 100                                 Assert.AreEqual("home\\index", viewEngStub.TemplateRendered);
 101                                 Assert.IsTrue(controller.indexActionExecuted);
 102                         }
 103                 }
 104
 105                 [Test]
 106                 public void Filter_AfterActionIsRun()
 107                 {
 108                         ControllerWithAfterActionFilter controller = new ControllerWithAfterActionFilter();
 109
 110                         IControllerContext context = services.ControllerContextFactory.
 111                                 Create("", "home", "index",
 112                                        services.ControllerDescriptorProvider.BuildDescriptor(controller));
 113
 114                         IFilter filterMock = mockRepository.CreateMock<IFilter>();
 115
 116                         using(mockRepository.Record())
 117                         {
 118                                 Expect.Call(filterFactoryMock.Create(typeof(DummyFilter))).Return(filterMock);
 119
 120                                 Expect.Call(filterMock.Perform(ExecuteWhen.AfterAction, engineContext, controller, context)).Return(true);
 121
 122                                 filterFactoryMock.Release(filterMock);
 123                                 LastCall.Repeat.Once();
 124                         }
 125
 126                         using(mockRepository.Playback())
 127                         {
 128                                 controller.Process(engineContext, context);
 129                                 controller.Dispose();
 130
 131                                 Assert.AreEqual("home\\index", viewEngStub.TemplateRendered);
 132                                 Assert.IsTrue(controller.indexActionExecuted);
 133                         }
 134                 }
 135
 136                 [Test]
 137                 public void Filter_AfterActionReturningFalsePreventsRendering()
 138                 {
 139                         ControllerWithAfterActionFilter controller = new ControllerWithAfterActionFilter();
 140
 141                         IControllerContext context = services.ControllerContextFactory.
 142                                 Create("", "home", "index",
 143                                        services.ControllerDescriptorProvider.BuildDescriptor(controller));
 144
 145                         IFilter filterMock = mockRepository.CreateMock<IFilter>();
 146
 147                         using(mockRepository.Record())
 148                         {
 149                                 Expect.Call(filterFactoryMock.Create(typeof(DummyFilter))).Return(filterMock);
 150
 151                                 Expect.Call(filterMock.Perform(ExecuteWhen.AfterAction, engineContext, controller, context)).Return(false);
 152
 153                                 filterFactoryMock.Release(filterMock);
 154                                 LastCall.Repeat.Once();
 155                         }
 156
 157                         using(mockRepository.Playback())
 158                         {
 159                                 controller.Process(engineContext, context);
 160                                 controller.Dispose();
 161
 162                                 Assert.IsNull(viewEngStub.TemplateRendered);
 163                                 Assert.IsTrue(controller.indexActionExecuted);
 164                         }
 165                 }
 166
 167                 [Test]
 168                 public void Filter_AfterRenderingIsRun()
 169                 {
 170                         ControllerWithAfterRenderingFilter controller = new ControllerWithAfterRenderingFilter();
 171
 172                         IControllerContext context = services.ControllerContextFactory.
 173                                 Create("", "home", "index",
 174                                        services.ControllerDescriptorProvider.BuildDescriptor(controller));
 175
 176                         IFilter filterMock = mockRepository.CreateMock<IFilter>();
 177
 178                         using(mockRepository.Record())
 179                         {
 180                                 Expect.Call(filterFactoryMock.Create(typeof(DummyFilter))).Return(filterMock);
 181
 182                                 Expect.Call(filterMock.Perform(ExecuteWhen.AfterRendering, engineContext, controller, context)).Return(true);
 183
 184                                 filterFactoryMock.Release(filterMock);
 185                                 LastCall.Repeat.Once();
 186                         }
 187
 188                         using(mockRepository.Playback())
 189                         {
 190                                 controller.Process(engineContext, context);
 191                                 controller.Dispose();
 192
 193                                 Assert.AreEqual("home\\index", viewEngStub.TemplateRendered);
 194                                 Assert.IsTrue(controller.indexActionExecuted);
 195                         }
 196                 }
 197
 198                 [Test]
 199                 public void Filter_SkipFilterAttributeSkipsTheFilter()
 200                 {
 201                         ControllerWithSkipFilter controller = new ControllerWithSkipFilter();
 202
 203                         IControllerContext context = services.ControllerContextFactory.
 204                                 Create("", "home", "index",
 205                                        services.ControllerDescriptorProvider.BuildDescriptor(controller));
 206
 207                         IFilter filterMock = mockRepository.CreateMock<IFilter>();
 208
 209                         using(mockRepository.Record())
 210                         {
 211                         }
 212
 213                         using(mockRepository.Playback())
 214                         {
 215                                 controller.Process(engineContext, context);
 216                                 controller.Dispose();
 217
 218                                 Assert.AreEqual("home\\index", viewEngStub.TemplateRendered);
 219                                 Assert.IsTrue(controller.indexActionExecuted);
 220                         }
 221                 }
 222
 223                 #region Controllers
 224
 225                 [Filter(ExecuteWhen.BeforeAction, typeof(DummyFilter))]
 226                 private class ControllerWithSingleBeforeActionFilter : Controller
 227                 {
 228                         public bool indexActionExecuted;
 229
 230                         public void Index()
 231                         {
 232                                 indexActionExecuted = true;
 233                         }
 234                 }
 235
 236                 [Filter(ExecuteWhen.BeforeAction, typeof(DummyFilter))]
 237                 private class ControllerWithSkipFilter : Controller
 238                 {
 239                         public bool indexActionExecuted;
 240
 241                         [SkipFilter]
 242                         public void Index()
 243                         {
 244                                 indexActionExecuted = true;
 245                         }
 246                 }
 247
 248                 [Filter(ExecuteWhen.AfterAction, typeof(DummyFilter))]
 249                 private class ControllerWithAfterActionFilter : Controller
 250                 {
 251                         public bool indexActionExecuted;
 252
 253                         public void Index()
 254                         {
 255                                 indexActionExecuted = true;
 256                         }
 257                 }
 258
 259                 [Filter(ExecuteWhen.AfterRendering, typeof(DummyFilter))]
 260                 private class ControllerWithAfterRenderingFilter : Controller
 261                 {
 262                         public bool indexActionExecuted;
 263
 264                         public void Index()
 265                         {
 266                                 indexActionExecuted = true;
 267                         }
 268                 }
 269
 270                 #endregion
 271
 272                 private class DummyFilter : IFilter
 273                 {
 274                         public bool Perform(ExecuteWhen exec, IEngineContext context, IController controller,
 275                                             IControllerContext controllerContext)
 276                         {
 277                                 return false;
 278                         }
 279                 }
 280         }
 281 }