public void ProcessRequestWithNormalControlFlowForAsynchronousController() {
// Arrange
Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
mockHttpContext.ExpectMvcVersionResponseHeader().Verifiable();
RequestContext requestContext = new RequestContext(mockHttpContext.Object, GetRouteData());
MvcAsyncHandler handler = new MvcAsyncHandler(requestContext);
MockAsyncResult asyncResult = new MockAsyncResult();
Mock<IAsyncController> mockController = new Mock<IAsyncController>();
mockController.Expect(c => c.BeginExecute(requestContext, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(asyncResult).Verifiable();
mockController.Expect(c => c.EndExecute(asyncResult)).Verifiable();
mockController.As<IDisposable>().Expect(c => c.Dispose()).AtMostOnce().Verifiable();
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
handler.ControllerBuilder = builder;
// Act
IAsyncResult returnedAsyncResult = handler.BeginProcessRequest(mockHttpContext.Object, null, null);
handler.EndProcessRequest(returnedAsyncResult);
mockHttpContext.Verify();
mockController.Verify();
}
public void ProcessRequestWhereControllerBeginExecuteThrows() {
// Arrange
Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
mockHttpContext.ExpectMvcVersionResponseHeader().Verifiable();
RequestContext requestContext = new RequestContext(mockHttpContext.Object, GetRouteData());
MvcAsyncHandler handler = new MvcAsyncHandler(requestContext);
Mock<IAsyncController> mockController = new Mock<IAsyncController>();
mockController.Expect(c => c.BeginExecute(requestContext, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Throws(new InvalidOperationException("Some exception text.")).Verifiable();
mockController.As<IDisposable>().Expect(c => c.Dispose()).AtMostOnce().Verifiable();
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
handler.ControllerBuilder = builder;
// Act
ExceptionHelper.ExpectInvalidOperationException(
delegate {
handler.BeginProcessRequest(mockHttpContext.Object, null, null);
},
@"Some exception text.");
mockHttpContext.Verify();
mockController.Verify();
}
public void ProcessRequestAddsServerHeaderCallsExecute() {
// Arrange
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
contextMock.Verify();
controllerMock.Verify();
}
public static void RegisterControllerFactory(ControllerBuilder controllerBuilder, IEngine engine)
{
engine.RegisterControllers(Assembly.GetExecutingAssembly());
var controllerFactory = engine.Resolve<ControllerFactoryConfigurator>()
//.NotFound<StartController>(sc => sc.NotFound())
.ControllerFactory;
controllerBuilder.SetControllerFactory(controllerFactory);
}
public void RegisterControllerFactory(ControllerBuilder controllerBuilder, IEngine engine)
{
engine.RegisterAllControllers();
var controllerFactory = engine.Resolve<ControllerFactoryConfigurator>()
.NotFound<StartController>(sc => sc.NotFound())
.ControllerFactory;
controllerBuilder.SetControllerFactory(controllerFactory);
}
public static void RegisterControllerFactory(ControllerBuilder controllerBuilder, IEngine engine)
{
// Registers controllers in the solution for dependency injection using the IoC container provided by N2
engine.RegisterAllControllers();
var controllerFactory = engine.Resolve<ControllerFactoryConfigurator>()
.NotFound<Controllers.StartPageController>(sc => sc.NotFound())
.ControllerFactory;
controllerBuilder.SetControllerFactory(controllerFactory);
}
public void CreateControllerWithFactoryInstanceReturnsInstance() {
// Arrange
ControllerBuilder cb = new ControllerBuilder();
DefaultControllerFactory factory = new DefaultControllerFactory();
cb.SetControllerFactory(factory);
// Act
IControllerFactory cf = cb.GetControllerFactory();
// Assert
Assert.AreSame(factory, cf);
}
public static void Start(HttpConfiguration config, ControllerBuilder builder)
{
// innitialize the IoC using Structure Map.
IoC.Initialize();
var container = ObjectFactory.Container;
// Standard settings for SM for MVC4.
config.DependencyResolver = new SmDependencyResolver(container);
// Used as a test to overide some issues with Injecting dependenices on Api controllers.
// Though the Api controllers are not used in this version of the application
builder.SetControllerFactory(new StructureMapControllerFactory());
}
public static void RegisterMvc(ControllerBuilder controllerBuilder, GlobalFilterCollection globalFilters)
{
//controllers
Container.Register<IController, HomeController>("Home").AsMultiInstance();
//filters
var filters = Container.ResolveAll<IMvcFilter>();
foreach (var filter in filters)
{
globalFilters.Add(filter);
}
//controller factory
controllerBuilder.SetControllerFactory(new TinyIocControllerFactory(Container));
}
public void CreateControllerWithFactoryThatCannotBeCreatedThrows() {
// Arrange
ControllerBuilder cb = new ControllerBuilder();
cb.SetControllerFactory(typeof(ControllerFactoryThrowsFromConstructor));
// Act
ExceptionHelper.ExpectException<InvalidOperationException>(
delegate {
RequestContext reqContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
reqContext.RouteData.Values["controller"] = "foo";
MvcHandlerWithNoVersionHeader handler = new MvcHandlerWithNoVersionHeader(reqContext) {
ControllerBuilder = cb
};
handler.ProcessRequest(reqContext.HttpContext);
},
"An error occurred when trying to create the IControllerFactory 'System.Web.Mvc.Test.ControllerBuilderTest+ControllerFactoryThrowsFromConstructor'. Make sure that the controller factory has a public parameterless constructor.");
}
public void CreateControllerWithFactoryThatReturnsNullThrows() {
// Arrange
ControllerBuilder cb = new ControllerBuilder();
cb.SetControllerFactory(typeof(ControllerFactoryReturnsNull));
// Act
ExceptionHelper.ExpectException<InvalidOperationException>(
delegate {
RequestContext reqContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
reqContext.RouteData.Values["controller"] = "boo";
MvcHandlerWithNoVersionHeader handler = new MvcHandlerWithNoVersionHeader(reqContext) {
ControllerBuilder = cb
};
handler.ProcessRequest(reqContext.HttpContext);
},
"The IControllerFactory 'System.Web.Mvc.Test.ControllerBuilderTest+ControllerFactoryReturnsNull' did not return a controller for the name 'boo'.");
}
public void CreateControllerWithFactoryThatThrowsDoesNothingSpecial() {
// Arrange
ControllerBuilder cb = new ControllerBuilder();
cb.SetControllerFactory(typeof(ControllerFactoryThrows));
// Act
ExceptionHelper.ExpectException<Exception>(
delegate {
RequestContext reqContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
reqContext.RouteData.Values["controller"] = "foo";
MvcHandlerWithNoVersionHeader handler = new MvcHandlerWithNoVersionHeader(reqContext) {
ControllerBuilder = cb
};
handler.ProcessRequest(reqContext.HttpContext);
},
"ControllerFactoryThrows");
}
public void GetHttpHandlerWithValidControllerDoesNotChangeRouteTest()
{
// Arrange
var mockController = new Mock<ControllerBase>(MockBehavior.Strict);
var expected = "fooController";
var builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
var contextMock = new Mock<HttpContextBase>();
var requestContext = new RequestContext(contextMock.Object, new RouteData());
requestContext.RouteData.Values["controller"] = expected;
// act
var handler = new PhunMvcRouteHandler() { ControllerBuilder = builder };
handler.PreHandleRequestInternal(requestContext);
// Assert
Assert.AreEqual(expected, requestContext.RouteData.Values["controller"]);
}
public void SetSessionStateMode_HandlerIsMvcHandler_ControllerHasNoAttribute_SetsDefault() {
// Arrange
RequestContext requestContext = GetRequestContext();
IHttpHandler originalHttpHandler = requestContext.HttpContext.Handler;
Mock<IControllerFactory> mockControllerFactory = new Mock<IControllerFactory>();
mockControllerFactory.Expect(o => o.CreateController(requestContext, "home")).Returns(new ControllerWithoutAttribute());
ControllerBuilder controllerBuilder = new ControllerBuilder();
controllerBuilder.SetControllerFactory(new MvcDynamicSessionControllerFactory(mockControllerFactory.Object));
MvcDynamicSessionModule module = new MvcDynamicSessionModule() {
ControllerBuilder = controllerBuilder
};
// Act
module.SetSessionStateMode(requestContext.HttpContext, SimpleDynamicSessionStateConfigurator.ExpectMode(ControllerSessionState.Default));
// Assert
Assert.AreEqual(2, requestContext.HttpContext.Items.Count, "Cache + factory weren't properly added to Items.");
}
public void ProcessRequestThrowsIfControllerNotFound() {
// Arrange
Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
mockHttpContext.ExpectMvcVersionResponseHeader().Verifiable();
RequestContext requestContext = new RequestContext(mockHttpContext.Object, GetRouteData());
MvcAsyncHandler handler = new MvcAsyncHandler(requestContext);
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(null));
handler.ControllerBuilder = builder;
// Act & assert
ExceptionHelper.ExpectInvalidOperationException(
delegate {
handler.BeginProcessRequest(mockHttpContext.Object, null, null);
},
@"The IControllerFactory 'Microsoft.Web.Mvc.Test.MvcAsyncHandlerTest+SimpleControllerFactory' did not return a controller for a controller named 'Foo'.");
mockHttpContext.Verify();
}
public void PossiblyReleaseController_CorrectFactory_ReleasesController() {
// Arrange
RequestContext requestContext = GetRequestContext();
IHttpHandler originalHttpHandler = requestContext.HttpContext.Handler;
Controller controller = new ControllerReadOnlySession();
Mock<IControllerFactory> mockControllerFactory = new Mock<IControllerFactory>();
mockControllerFactory.Expect(o => o.CreateController(requestContext, "home")).Returns(controller);
mockControllerFactory.Expect(o => o.ReleaseController(controller)).Verifiable();
ControllerBuilder controllerBuilder = new ControllerBuilder();
controllerBuilder.SetControllerFactory(new MvcDynamicSessionControllerFactory(mockControllerFactory.Object));
MvcDynamicSessionModule module = new MvcDynamicSessionModule() {
ControllerBuilder = controllerBuilder
};
// Act
module.SetSessionStateMode(requestContext.HttpContext, SimpleDynamicSessionStateConfigurator.ExpectMode(ControllerSessionState.ReadOnly));
MvcDynamicSessionModule.PossiblyReleaseController(requestContext.HttpContext);
// Assert
mockControllerFactory.Verify();
}
public void ProcessRequestRemovesOptionalParametersFromRouteValueDictionary() {
// Arrange
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
rd.Values.Add("optional", UrlParameter.Optional);
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
controllerMock.Verify();
Assert.IsFalse(rd.Values.ContainsKey("optional"), "Optional value should have been removed.");
}
public void CreateControllerWithFactoryTypeReturnsValidType() {
// Arrange
ControllerBuilder cb = new ControllerBuilder();
cb.SetControllerFactory(typeof(MockControllerFactory));
// Act
IControllerFactory cf = cb.GetControllerFactory();
// Assert
Assert.IsInstanceOfType(cf, typeof(MockControllerFactory));
}
public void SettingControllerFactoryReturnsSetFactory() {
// Arrange
ControllerBuilder builder = new ControllerBuilder();
Mock<IControllerFactory> setFactory = new Mock<IControllerFactory>();
// Act
builder.SetControllerFactory(setFactory.Object);
// Assert
Assert.AreSame(setFactory.Object, builder.GetControllerFactory());
}
public PluginControllerFactory SetControllerFactory(ControllerBuilder builder, IControllerFactory fallbackFactory)
{
var factory = new PluginControllerFactory(this) { FallbackFactory = fallbackFactory };
builder.SetControllerFactory(factory);
return factory;
}
public PluginControllerFactory SetControllerFactory(ControllerBuilder builder)
{
var factory = new PluginControllerFactory(this);
builder.SetControllerFactory(factory);
return factory;
}
public void ProcessRequestWithDisabledServerHeaderOnlyCallsExecute() {
bool oldResponseHeaderValue = MvcHandler.DisableMvcResponseHeader;
try {
// Arrange
MvcHandler.DisableMvcResponseHeader = true;
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
RouteData rd = new RouteData();
rd.Values.Add("controller", "foo");
RequestContext requestContext = new RequestContext(contextMock.Object, rd);
MvcHandler mvcHandler = new MvcHandler(requestContext);
Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
controllerMock.Protected().Setup("Execute", requestContext).Verifiable();
ControllerBuilder cb = new ControllerBuilder();
Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
cb.SetControllerFactory(controllerFactoryMock.Object);
mvcHandler.ControllerBuilder = cb;
// Act
mvcHandler.ProcessRequest(contextMock.Object);
// Assert
controllerMock.Verify();
}
finally {
MvcHandler.DisableMvcResponseHeader = oldResponseHeaderValue;
}
}
public void ProcessRequestDisposesControllerIfExecuteDoesNotThrowException() {
// Arrange
Mock<ControllerBase> mockController = new Mock<ControllerBase>();
mockController.Protected().Expect("Execute", ItExpr.IsAny<RequestContext>()).Verifiable();
mockController.As<IDisposable>().Expect(d => d.Dispose()).AtMostOnce().Verifiable();
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>();
responseMock.Expect(r => r.AppendHeader(MvcHandler.MvcVersionHeaderName, "1.0")).Verifiable();
contextMock.Expect(c => c.Response).Returns(responseMock.Object);
RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
requestContext.RouteData.Values["controller"] = "fooController";
MvcHandler handler = new MvcHandler(requestContext) {
ControllerBuilder = builder
};
// Act
handler.ProcessRequest(requestContext.HttpContext);
// Assert
mockController.Verify();
responseMock.Verify();
}
public void SetControllerFactoryTypeWithNonFactoryTypeThrows() {
ControllerBuilder cb = new ControllerBuilder();
ExceptionHelper.ExpectArgumentException(
delegate {
cb.SetControllerFactory(typeof(int));
},
"The controller factory type 'System.Int32' must implement the IControllerFactory interface.\r\nParameter name: controllerFactoryType");
}
public void SetControllerFactoryTypeWithNullThrows() {
ControllerBuilder cb = new ControllerBuilder();
ExceptionHelper.ExpectArgumentNullException(
delegate {
cb.SetControllerFactory((Type)null);
},
"controllerFactoryType");
}
public void ProcessRequestDisposesControllerIfExecuteThrowsException() {
// Arrange
Mock<ControllerBase> mockController = new Mock<ControllerBase>(MockBehavior.Strict);
mockController.As<IDisposable>().Setup(d => d.Dispose()); // so that Verify can be called on Dispose later
mockController.Protected().Setup("Execute", ItExpr.IsAny<RequestContext>()).Throws(new Exception("some exception"));
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
contextMock.ExpectMvcVersionResponseHeader().Verifiable();
RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
requestContext.RouteData.Values["controller"] = "fooController";
MvcHandler handler = new MvcHandler(requestContext) {
ControllerBuilder = builder
};
// Act
ExceptionHelper.ExpectException<Exception>(
delegate {
handler.ProcessRequest(requestContext.HttpContext);
},
"some exception");
// Assert
mockController.Verify();
contextMock.Verify();
mockController.As<IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce());
}
public void ProcessRequestWithNormalControlFlowForSynchronousController() {
// Arrange
Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
mockHttpContext.Expect(c => c.Response.AppendHeader(MvcHandler.MvcVersionHeaderName, "1.0")).Verifiable();
RequestContext requestContext = new RequestContext(mockHttpContext.Object, GetRouteData());
MvcAsyncHandler handler = new MvcAsyncHandler(requestContext);
Mock<IController> mockController = new Mock<IController>();
mockController.Expect(c => c.Execute(requestContext)).Verifiable();
mockController.As<IDisposable>().Expect(c => c.Dispose()).AtMostOnce().Verifiable();
ControllerBuilder builder = new ControllerBuilder();
builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));
handler.ControllerBuilder = builder;
// Act
IAsyncResult asyncResult = handler.BeginProcessRequest(mockHttpContext.Object, null, null);
handler.EndProcessRequest(asyncResult);
mockHttpContext.Verify();
mockController.Verify();
}
private static MvcHandler GetMvcHandler(IController controller) {
Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
mockHttpContext.Setup(o => o.Response.AddHeader("X-AspNetMvc-Version", "2.0"));
RouteData routeData = new RouteData();
routeData.Values["controller"] = "SomeController";
RequestContext requestContext = new RequestContext(mockHttpContext.Object, routeData);
ControllerBuilder controllerBuilder = new ControllerBuilder();
controllerBuilder.SetControllerFactory(new SimpleControllerFactory(controller));
return new MvcHandler(requestContext) {
ControllerBuilder = controllerBuilder
};
}