MonoRail/Castle.MonoRail.Framework.Tests/Providers/DefaultControllerDescriptorProviderTestCase.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.Providers
  16 {
  17         using System;
  18         using System.Reflection;
  19         using Castle.MonoRail.Framework.Providers;
  20         using Descriptors;
  21         using NUnit.Framework;
  22         using Rhino.Mocks;
  23
  24         [TestFixture]
  25         public class DefaultControllerDescriptorProviderTestCase
  26         {
  27                 private MockRepository mockRepository = new MockRepository();
  28                 private DefaultControllerDescriptorProvider provider;
  29                 private IHelperDescriptorProvider helperDescProviderMock;
  30                 private IFilterDescriptorProvider filterDescProviderMock;
  31                 private ILayoutDescriptorProvider layoutDescProviderMock;
  32                 private IRescueDescriptorProvider rescueDescProviderMock;
  33                 private IResourceDescriptorProvider resourceProviderMock;
  34                 private ITransformFilterDescriptorProvider transformDescProviderMock;
  35                 private IReturnBinderDescriptorProvider returnTypeDescProviderMock;
  36
  37                 [Test]
  38                 public void CollectsSkipRescueForAction()
  39                 {
  40                         BuildDescriptor();
  41
  42                         Type controllerType = typeof(SkipRescueController);
  43
  44                         ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
  45                         Assert.IsNotNull(metaDesc);
  46                         MethodInfo actionMethod = controllerType.GetMethod("Action1");
  47                         ActionMetaDescriptor actionMetaDesc = metaDesc.GetAction(actionMethod);
  48                         Assert.IsNotNull(actionMetaDesc);
  49                         Assert.IsNotNull(actionMetaDesc.SkipRescue);
  50                 }
  51
  52                 [Test]
  53                 public void CollectsDefaultActionForController()
  54                 {
  55                         BuildDescriptor();
  56
  57                         Type controllerType = typeof(DefActionController);
  58
  59                         ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
  60                         Assert.IsNotNull(metaDesc);
  61                         Assert.IsNotNull(metaDesc.DefaultAction);
  62                         Assert.AreEqual("action", metaDesc.DefaultAction.DefaultAction);
  63                 }
  64
  65                 [Test]
  66                 public void CollectsDynamicActionsForController()
  67                 {
  68                         BuildDescriptor();
  69
  70                         Type controllerType = typeof(DynActionController);
  71
  72                         ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
  73                         Assert.IsNotNull(metaDesc);
  74                         Assert.AreEqual(1, metaDesc.ActionProviders.Count);
  75                         Assert.AreEqual(typeof(DummyDynActionProvider), metaDesc.ActionProviders[0]);
  76                 }
  77
  78                 [Test]
  79                 public void CollectsScaffoldingForController()
  80                 {
  81                         BuildDescriptor();
  82
  83                         Type controllerType = typeof(ScaffoldController);
  84
  85                         ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
  86                         Assert.IsNotNull(metaDesc);
  87                         Assert.AreEqual(1, metaDesc.Scaffoldings.Count);
  88                         Assert.AreEqual(typeof(DummyScaffoldEntity), metaDesc.Scaffoldings[0].Model);
  89                 }
  90
  91                 [Test]
  92                 public void CollectsSkipFilterForAction()
  93                 {
  94                         BuildDescriptor();
  95
  96                         Type controllerType = typeof(SkipFilterController);
  97
  98                         ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
  99                         Assert.IsNotNull(metaDesc);
 100                         MethodInfo actionMethod = controllerType.GetMethod("Action1");
 101                         ActionMetaDescriptor actionMetaDesc = metaDesc.GetAction(actionMethod);
 102                         Assert.IsNotNull(actionMetaDesc);
 103                         Assert.IsNotNull(actionMetaDesc.SkipFilters);
 104                 }
 105
 106                 [Test]
 107                 public void CollectsAccessibleThroughForAction()
 108                 {
 109                         BuildDescriptor();
 110
 111                         Type controllerType = typeof(AccThrController);
 112
 113                         ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
 114                         Assert.IsNotNull(metaDesc);
 115                         MethodInfo actionMethod = controllerType.GetMethod("Action1");
 116                         ActionMetaDescriptor actionMetaDesc = metaDesc.GetAction(actionMethod);
 117                         Assert.IsNotNull(actionMetaDesc);
 118                         Assert.IsNotNull(actionMetaDesc.AccessibleThrough);
 119                 }
 120
 121                 [Test]
 122                 public void DescriptorIsCreatedForControllerAndAction()
 123                 {
 124                         helperDescProviderMock = mockRepository.CreateMock<IHelperDescriptorProvider>();
 125                         filterDescProviderMock = mockRepository.CreateMock<IFilterDescriptorProvider>();
 126                         layoutDescProviderMock = mockRepository.CreateMock<ILayoutDescriptorProvider>();
 127                         rescueDescProviderMock = mockRepository.CreateMock<IRescueDescriptorProvider>();
 128                         resourceProviderMock = mockRepository.CreateMock<IResourceDescriptorProvider>();
 129                         transformDescProviderMock = mockRepository.CreateMock<ITransformFilterDescriptorProvider>();
 130                         returnTypeDescProviderMock = mockRepository.CreateMock<IReturnBinderDescriptorProvider>();
 131
 132                         provider = new DefaultControllerDescriptorProvider(helperDescProviderMock,
 133                                                                                                                            filterDescProviderMock,
 134                                                                                                                            layoutDescProviderMock,
 135                                                                                                                            rescueDescProviderMock,
 136                                                                                                                            resourceProviderMock,
 137                                                                                                                            transformDescProviderMock, returnTypeDescProviderMock);
 138
 139                         Type controllerType = typeof(SingleActionController);
 140                         MethodInfo actionMethod = controllerType.GetMethod("Action1");
 141
 142                         using(mockRepository.Record())
 143                         {
 144                                 // Controller level
 145                                 Expect.Call(helperDescProviderMock.CollectHelpers(controllerType)).Return(new HelperDescriptor[0]);
 146                                 Expect.Call(resourceProviderMock.CollectResources(controllerType)).Return(new ResourceDescriptor[0]);
 147                                 Expect.Call(filterDescProviderMock.CollectFilters(controllerType)).Return(new FilterDescriptor[0]);
 148                                 Expect.Call(layoutDescProviderMock.CollectLayout(controllerType)).Return(null);
 149                                 Expect.Call(rescueDescProviderMock.CollectRescues(controllerType)).Return(new RescueDescriptor[0]);
 150
 151                                 // Action level
 152                                 Expect.Call(resourceProviderMock.CollectResources(actionMethod)).Return(new ResourceDescriptor[0]);
 153                                 Expect.Call(rescueDescProviderMock.CollectRescues(actionMethod)).Return(new RescueDescriptor[0]);
 154                                 Expect.Call(layoutDescProviderMock.CollectLayout(actionMethod)).Return(null);
 155                                 Expect.Call(transformDescProviderMock.CollectFilters(actionMethod)).Return(new TransformFilterDescriptor[0]);
 156                                 Expect.Call(returnTypeDescProviderMock.Collect(actionMethod)).Return(null);
 157                         }
 158
 159                         using(mockRepository.Playback())
 160                         {
 161                                 ControllerMetaDescriptor metaDesc = provider.BuildDescriptor(controllerType);
 162                                 Assert.IsNotNull(metaDesc);
 163                                 ActionMetaDescriptor actionMetaDesc = metaDesc.GetAction(actionMethod);
 164                                 Assert.IsNotNull(actionMetaDesc);
 165                                 Assert.IsNull(actionMetaDesc.AccessibleThrough);
 166                         }
 167                 }
 168
 169                 #region Controllers
 170
 171                 public class SingleActionController : Controller
 172                 {
 173                         public void Action1()
 174                         {
 175                         }
 176                 }
 177
 178                 public class AccThrController : Controller
 179                 {
 180                         [AccessibleThrough(Verb.Post)]
 181                         public void Action1()
 182                         {
 183                         }
 184                 }
 185
 186                 public class SkipRescueController : Controller
 187                 {
 188                         [SkipRescue]
 189                         public void Action1()
 190                         {
 191                         }
 192                 }
 193
 194                 public class SkipFilterController : Controller
 195                 {
 196                         [SkipFilter]
 197                         public void Action1()
 198                         {
 199                         }
 200                 }
 201
 202                 [DynamicActionProvider(typeof(DummyDynActionProvider))]
 203                 public class DynActionController : Controller
 204                 {
 205                 }
 206
 207                 public class DummyDynActionProvider : IDynamicActionProvider
 208                 {
 209                         public void IncludeActions(IEngineContext engineContext, IController controller, IControllerContext controllerContext)
 210                         {
 211                         }
 212                 }
 213
 214                 [Scaffolding(typeof(DummyScaffoldEntity))]
 215                 public class ScaffoldController : Controller
 216                 {
 217
 218                 }
 219
 220                 public class DummyScaffoldEntity
 221                 {
 222                 }
 223
 224                 [DefaultAction("action")]
 225                 public class DefActionController : Controller
 226                 {
 227                 }
 228
 229                 #endregion
 230
 231                 private void BuildDescriptor()
 232                 {
 233                         provider = new DefaultControllerDescriptorProvider(new DefaultHelperDescriptorProvider(),
 234                                                                                                                            new DefaultFilterDescriptorProvider(), new DefaultLayoutDescriptorProvider(),
 235                                                                                                                            new DefaultRescueDescriptorProvider(), new DefaultResourceDescriptorProvider(),
 236                                                                                                                            new DefaultTransformFilterDescriptorProvider(), new DefaultReturnBinderDescriptorProvider());
 237                 }
 238         }
 239 }