MonoRail/Castle.MonoRail.Framework.Tests/Handlers/MRHandlerFactoryTestCase.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.Handlers
  16 {
  17         using System;
  18         using System.IO;
  19         using System.Web;
  20         using Castle.MonoRail.Framework.Configuration;
  21         using Castle.MonoRail.Framework.Providers;
  22         using Castle.MonoRail.Framework.Routing;
  23         using Castle.MonoRail.Framework.Services;
  24         using Container;
  25         using Descriptors;
  26         using NUnit.Framework;
  27         using Rhino.Mocks;
  28
  29         [TestFixture]
  30         public class MRHandlerFactoryTestCase
  31         {
  32                 private readonly MockRepository mockRepository = new MockRepository();
  33                 private MonoRailHttpHandlerFactory handlerFactory;
  34                 private IServiceProviderLocator serviceProviderLocatorMock;
  35                 private IMonoRailContainer container;
  36                 private IControllerFactory controllerFactoryMock;
  37                 private IAsyncController controllerMock;
  38                 private IControllerDescriptorProvider controllerDescriptorProviderMock;
  39                 private IControllerContextFactory controllerContextFactoryMock;
  40
  41                 [SetUp]
  42                 public void Init()
  43                 {
  44                         container = mockRepository.CreateMock<IMonoRailContainer>();
  45                         serviceProviderLocatorMock = mockRepository.CreateMock<IServiceProviderLocator>();
  46                         controllerFactoryMock = mockRepository.CreateMock<IControllerFactory>();
  47                         controllerMock = mockRepository.CreateMock<IAsyncController>();
  48                         controllerDescriptorProviderMock = mockRepository.CreateMock<IControllerDescriptorProvider>();
  49                         controllerContextFactoryMock = mockRepository.CreateMock<IControllerContextFactory>();
  50
  51                         SetupResult.For(container.UrlTokenizer).Return(new DefaultUrlTokenizer());
  52                         SetupResult.For(container.UrlBuilder).Return(new DefaultUrlBuilder());
  53                         SetupResult.For(container.EngineContextFactory).Return(new DefaultEngineContextFactory());
  54                         SetupResult.For(container.ControllerFactory).Return(controllerFactoryMock);
  55                         SetupResult.For(container.ControllerContextFactory).Return(controllerContextFactoryMock);
  56                         SetupResult.For(container.ControllerDescriptorProvider).Return(controllerDescriptorProviderMock);
  57                         SetupResult.For(container.StaticResourceRegistry).Return(new DefaultStaticResourceRegistry());
  58
  59                         handlerFactory = new MonoRailHttpHandlerFactory(serviceProviderLocatorMock);
  60                         handlerFactory.ResetState();
  61                         handlerFactory.Configuration = new MonoRailConfiguration();
  62                         handlerFactory.Container = container;
  63                 }
  64
  65                 [Test]
  66                 public void Request_CreatesSessionfulHandler()
  67                 {
  68                         StringWriter writer = new StringWriter();
  69
  70                         HttpResponse res = new HttpResponse(writer);
  71                         HttpRequest req = new HttpRequest(Path.Combine(
  72                                                                 AppDomain.CurrentDomain.BaseDirectory, "Handlers/Files/simplerequest.txt"),
  73                                                           "http://localhost:1333/home/something", "");
  74                         RouteMatch routeMatch = new RouteMatch();
  75                         HttpContext httpCtx = new HttpContext(req, res);
  76                         httpCtx.Items[RouteMatch.RouteMatchKey] = routeMatch;
  77
  78                         using(mockRepository.Record())
  79                         {
  80                                 ControllerMetaDescriptor controllerDesc = new ControllerMetaDescriptor();
  81                                 controllerDesc.ControllerDescriptor = new ControllerDescriptor(typeof(Controller), "home", "", false);
  82
  83                                 Expect.Call(controllerFactoryMock.CreateController("", "home")).IgnoreArguments().Return(controllerMock);
  84                                 Expect.Call(controllerDescriptorProviderMock.BuildDescriptor(controllerMock)).Return(controllerDesc);
  85                             ControllerContext controllerContext = new ControllerContext();
  86                 controllerContext.ControllerDescriptor = new ControllerMetaDescriptor();
  87                             Expect.Call(controllerContextFactoryMock.Create("", "home", "something", controllerDesc, routeMatch)).
  88                                         Return(controllerContext);
  89                         }
  90
  91                         using(mockRepository.Playback())
  92                         {
  93                                 IHttpHandler handler = handlerFactory.GetHandler(httpCtx, "GET", "", "");
  94
  95                                 Assert.IsNotNull(handler);
  96                                 Assert.IsInstanceOfType(typeof(MonoRailHttpHandler), handler);
  97                         }
  98                 }
  99
 100         [Test]
 101         public void Request_CreatesSessionfulHandler_Async()
 102         {
 103             StringWriter writer = new StringWriter();
 104
 105             HttpResponse res = new HttpResponse(writer);
 106             HttpRequest req = new HttpRequest(Path.Combine(
 107                                                 AppDomain.CurrentDomain.BaseDirectory, "Handlers/Files/simplerequest.txt"),
 108                                               "http://localhost:1333/home/something", "");
 109             RouteMatch routeMatch = new RouteMatch();
 110             HttpContext httpCtx = new HttpContext(req, res);
 111             httpCtx.Items[RouteMatch.RouteMatchKey] = routeMatch;
 112
 113             using (mockRepository.Record())
 114             {
 115                 ControllerMetaDescriptor controllerDesc = new ControllerMetaDescriptor();
 116                 controllerDesc.ControllerDescriptor = new ControllerDescriptor(typeof(Controller), "home", "", false);
 117
 118                 Expect.Call(controllerFactoryMock.CreateController("", "home")).IgnoreArguments().Return(controllerMock);
 119                 Expect.Call(controllerDescriptorProviderMock.BuildDescriptor(controllerMock)).Return(controllerDesc);
 120                 ControllerContext controllerContext = new ControllerContext();
 121                 controllerContext.ControllerDescriptor = new ControllerMetaDescriptor();
 122                 controllerContext.Action = "something";
 123                 controllerContext.ControllerDescriptor.Actions["something"] = new AsyncActionPair(null, null, null);
 124                 Expect.Call(controllerContextFactoryMock.Create("", "home", "something", controllerDesc, routeMatch)).
 125                     Return(controllerContext);
 126             }
 127
 128             using (mockRepository.Playback())
 129             {
 130                 IHttpHandler handler = handlerFactory.GetHandler(httpCtx, "GET", "", "");
 131
 132                 Assert.IsNotNull(handler);
 133                 Assert.IsInstanceOfType(typeof(AsyncMonoRailHttpHandler), handler);
 134             }
 135         }
 136
 137                 [Test]
 138                 public void Request_CreatesSessionlessHandler()
 139                 {
 140                         StringWriter writer = new StringWriter();
 141
 142                         HttpResponse res = new HttpResponse(writer);
 143                         HttpRequest req = new HttpRequest(Path.Combine(
 144                                                                 AppDomain.CurrentDomain.BaseDirectory, "Handlers/Files/simplerequest.txt"),
 145                                                           "http://localhost:1333/home/something", "");
 146                         RouteMatch routeMatch = new RouteMatch();
 147                         HttpContext httpCtx = new HttpContext(req, res);
 148                         httpCtx.Items[RouteMatch.RouteMatchKey] = routeMatch;
 149
 150                         using(mockRepository.Record())
 151                         {
 152                                 ControllerMetaDescriptor controllerDesc = new ControllerMetaDescriptor();
 153                                 controllerDesc.ControllerDescriptor = new ControllerDescriptor(typeof(Controller), "home", "", true);
 154
 155                                 Expect.Call(controllerFactoryMock.CreateController("", "home")).IgnoreArguments().Return(controllerMock);
 156                                 Expect.Call(controllerDescriptorProviderMock.BuildDescriptor(controllerMock)).Return(controllerDesc);
 157                 ControllerContext controllerContext = new ControllerContext();
 158                 controllerContext.ControllerDescriptor = new ControllerMetaDescriptor();
 159                 Expect.Call(controllerContextFactoryMock.Create("", "home", "something", controllerDesc, routeMatch)).
 160                     Return(controllerContext);
 161                         }
 162
 163                         using(mockRepository.Playback())
 164                         {
 165                                 IHttpHandler handler = handlerFactory.GetHandler(httpCtx, "GET", "", "");
 166
 167                                 Assert.IsNotNull(handler);
 168                                 Assert.IsInstanceOfType(typeof(SessionlessMonoRailHttpHandler), handler);
 169                         }
 170                 }
 171
 172         [Test]
 173         public void Request_CreatesSessionlessHandler_Async()
 174         {
 175             StringWriter writer = new StringWriter();
 176
 177             HttpResponse res = new HttpResponse(writer);
 178             HttpRequest req = new HttpRequest(Path.Combine(
 179                                                 AppDomain.CurrentDomain.BaseDirectory, "Handlers/Files/simplerequest.txt"),
 180                                               "http://localhost:1333/home/something", "");
 181             RouteMatch routeMatch = new RouteMatch();
 182             HttpContext httpCtx = new HttpContext(req, res);
 183             httpCtx.Items[RouteMatch.RouteMatchKey] = routeMatch;
 184
 185             using (mockRepository.Record())
 186             {
 187                 ControllerMetaDescriptor controllerDesc = new ControllerMetaDescriptor();
 188                 controllerDesc.ControllerDescriptor = new ControllerDescriptor(typeof(Controller), "home", "", true);
 189
 190                 Expect.Call(controllerFactoryMock.CreateController("", "home")).IgnoreArguments().Return(controllerMock);
 191                 Expect.Call(controllerDescriptorProviderMock.BuildDescriptor(controllerMock)).Return(controllerDesc);
 192                 ControllerContext controllerContext = new ControllerContext();
 193                 controllerContext.Action = "something";
 194                 controllerContext.ControllerDescriptor = new ControllerMetaDescriptor();
 195                 controllerContext.ControllerDescriptor.Actions["something"] = new AsyncActionPair(null,null,null);
 196                 Expect.Call(controllerContextFactoryMock.Create("", "home", "something", controllerDesc, routeMatch)).
 197                     Return(controllerContext);
 198             }
 199
 200             using (mockRepository.Playback())
 201             {
 202                 IHttpHandler handler = handlerFactory.GetHandler(httpCtx, "GET", "", "");
 203
 204                 Assert.IsNotNull(handler);
 205                 Assert.IsInstanceOfType(typeof(AsyncSessionlessMonoRailHttpHandler), handler);
 206             }
 207         }
 208         }
 209 }