public void POST_Not_Providing_Reset_Code_In_URL_Gives_PageNotFoundException() { // Arrange User user = new UserBuilder().WithPasswordResetCode("code").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_NewPassword", "NewPassword1"); requestFormValues.Add("GovUk_Text_ConfirmNewPassword", "NewPassword1"); var controllerBuilder = new ControllerBuilder <PasswordResetController>(); var controller = controllerBuilder .WithDatabaseObjects(user) .WithRequestFormValues(requestFormValues) .WithMockUriHelper() .Build(); // Act var requestViewModel = new ChooseNewPasswordViewModel { ResetCode = null /* reset code not provided */ }; TestDelegate action = () => controller.ChooseNewPasswordPost(requestViewModel); // Assert Assert.Throws <PageNotFoundException>(action); }
public void POST_Password_Reset_Email_Is_Sent_When_Valid_Email_Address_Is_Provided() { // Arrange User user = new UserBuilder().WithEmailAddress("*****@*****.**").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_EmailAddress", "*****@*****.**"); var controllerBuilder = new ControllerBuilder <PasswordResetController>(); var controller = controllerBuilder .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); // Act controller.PasswordResetPost(new PasswordResetViewModel()); // Assert Assert.AreEqual(1, controllerBuilder.EmailsSent.Count); var email = controllerBuilder.EmailsSent.FirstOrDefault(); Assert.NotNull(email); Assert.AreEqual(EmailTemplates.SendResetPasswordVerificationEmail, email.TemplateId); Assert.AreEqual(user.EmailAddress, email.EmailAddress); }
private static void RunEntityBuilders(string solutionDirectory, ApiTemplate template, IFileSystem fileSystem) { //entities foreach (var entity in template.Entities) { EntityBuilder.CreateEntity(solutionDirectory, entity, fileSystem); DtoBuilder.CreateDtos(solutionDirectory, entity); RepositoryBuilder.AddRepository(solutionDirectory, entity, template.DbContext); ValidatorBuilder.CreateValidators(solutionDirectory, entity); ProfileBuilder.CreateProfile(solutionDirectory, entity); ControllerBuilder.CreateController(solutionDirectory, entity, template.SwaggerConfig.AddSwaggerComments); FakesBuilder.CreateFakes(solutionDirectory, template, entity); ReadTestBuilder.CreateEntityReadTests(solutionDirectory, template, entity); GetTestBuilder.CreateEntityGetTests(solutionDirectory, template, entity); PostTestBuilder.CreateEntityWriteTests(solutionDirectory, template, entity); UpdateTestBuilder.CreateEntityUpdateTests(solutionDirectory, template, entity); DeleteTestBuilder.DeleteEntityWriteTests(solutionDirectory, template, entity); } //seeders & dbsets SeederModifier.AddSeeders(solutionDirectory, template); DbContextModifier.AddDbSet(solutionDirectory, template); }
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 static void ScaffoldEntities(string solutionDirectory, string srcDirectory, string testDirectory, string projectBaseName, List <Entity> entities, string dbContextName, bool addSwaggerComments, bool useSoftDelete, IFileSystem fileSystem) { foreach (var entity in entities) { // not worrying about DTOs, profiles, validators, fakers - they are all added by default EntityBuilder.CreateEntity(solutionDirectory, srcDirectory, entity, projectBaseName, fileSystem); DtoBuilder.CreateDtos(solutionDirectory, entity, projectBaseName); ValidatorBuilder.CreateValidators(solutionDirectory, srcDirectory, projectBaseName, entity); ProfileBuilder.CreateProfile(srcDirectory, entity, projectBaseName); ApiRouteModifier.AddRoutes(testDirectory, entity, projectBaseName); // api routes always added to testing by default. too much of a pain to scaffold dynamically var isProtected = entity.Features.Any(f => f.IsProtected); // <-- one more example of why it would be nice to have specific endpoints for each feature 😤 if (entity.Features.Count > 0) { ControllerBuilder.CreateController(solutionDirectory, srcDirectory, entity.Name, entity.Plural, projectBaseName, isProtected, fileSystem); } // TODO refactor to factory? foreach (var feature in entity.Features) { AddFeatureToProject(solutionDirectory, srcDirectory, testDirectory, projectBaseName, dbContextName, addSwaggerComments, feature, entity, useSoftDelete, fileSystem); } // Shared Tests FakesBuilder.CreateFakes(solutionDirectory, testDirectory, projectBaseName, entity, fileSystem); } }
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 AccountContext() { rUser = new GenericRepository<User>((u,n)=>u.Name ==n); rAccount = new GenericRepository<Account>((a,n)=>a.Number==n); AccountService = new AccountService(rUser, rAccount); cb = new ControllerBuilder(AccountService); }
public void ControllerBuilder_ControllerWithMultipleConstructors_WillUseOneMarkedWithApiContructorAttr() { var ctrlBuilder = new ControllerBuilder((new Moq.Mock <IServiceProvider>()).Object); var ctrl = ctrlBuilder.BuildObject <Controllers.BuilderTestController>(); Assert.Equal("default", ctrl.StrVal); }
public void Install( ControllerBuilder controllerBuilder, IContainer container, Action <RequestContext, IServiceLocator> requestScopeInitializer, params Assembly[] controllerAssemblies) { container.Setup( setup => { setup.RegisterPlugin( ps => ps.CustomInstanceCreators.Add(new ControllerIndex.ControllerIndexPlugin())); RegisterControllerNameExtractor(setup); foreach (var asm in controllerAssemblies) { setup.ScanAssembly(asm); } setup.For <ControllerIndex>().Use <ControllerIndex>(); }); var factory = new RaControllerFactory(container, requestScopeInitializer); controllerBuilder?.SetControllerFactory(factory); }
public void ConfigureServices(IServiceCollection services) { services.AddLogging(builder => { builder.ClearProviders(); builder.AddConsole(); builder.AddDebug(); }); services.AddHealthChecks(); var service = new Service(); services.AddSingleton <IService>(service); foreach (var command in service.Commands) { services.AddScoped(command.GetType()); } services.AddControllers().AddApplicationPart(Assembly.Load(ControllerBuilder.CreateControllerCode(service))); services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo { Title = $"My {service.GetType().FullName} Service.", Version = "v1" }); }); }
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 void CreateControllerWithFactoryThatReturnsNullThrows() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(ControllerFactoryReturnsNull)); // Act Assert.Throws <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 POST_Email_Is_Sent_When_Password_Is_Successfully_Updated() { // Arrange User user = new UserBuilder().WithPassword("password").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_CurrentPassword", "password"); requestFormValues.Add("GovUk_Text_NewPassword", "NewPassword1"); requestFormValues.Add("GovUk_Text_ConfirmNewPassword", "NewPassword1"); var controllerBuilder = new ControllerBuilder <ChangePasswordController>(); var controller = controllerBuilder .WithLoggedInUser(user) .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); // Act controller.ChangePasswordPost(new ChangePasswordViewModel()); // Assert // Assert that exactly one email is sent Assert.AreEqual(1, controllerBuilder.EmailsSent.Count); NotifyEmail userEmail = controllerBuilder.EmailsSent.FirstOrDefault(); // Assert that the email sent has the correct email address and template Assert.NotNull(userEmail); Assert.AreEqual(user.EmailAddress, userEmail.EmailAddress); Assert.AreEqual(EmailTemplates.SendChangePasswordCompletedEmail, userEmail.TemplateId, $"Expected the correct templateId to be in the email send queue, expected {EmailTemplates.SendChangePasswordCompletedEmail}"); }
public void RoutedByAttribute() { ControllerBuilder.AddAttribute(MvcConstants.RouteAttributeFullName_AspNetCore) .AddStringConstructorArg("api/Things/[action]").Commit(); AssertRouteEquals("/api/Things/RandoMethod"); }
public void POST_User_Is_Logged_Out_If_Failing_To_Change_The_Password_For_Five_Times() { // Arrange User user = new UserBuilder().WithPassword("password").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_CurrentPassword", "incorrect_password"); requestFormValues.Add("GovUk_Text_NewPassword", "Password1"); requestFormValues.Add("GovUk_Text_ConfirmNewPassword", "Password1"); var controller = new ControllerBuilder <ChangePasswordController>() .WithLoggedInUser(user) .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); // Act controller.ChangePasswordPost(new ChangePasswordViewModel()); controller.ChangePasswordPost(new ChangePasswordViewModel()); controller.ChangePasswordPost(new ChangePasswordViewModel()); controller.ChangePasswordPost(new ChangePasswordViewModel()); var result = controller.ChangePasswordPost(new ChangePasswordViewModel()) as RedirectToActionResult; // Assert Assert.That(result != null, "Expected RedirectToActionResult"); Assert.That(result.ActionName == "LoggedOut", "Expected redirect to LoggedOut"); }
public void POST_Password_Is_Updated_As_Expected() { // Arrange User user = new UserBuilder().WithPassword("password").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_CurrentPassword", "password"); requestFormValues.Add("GovUk_Text_NewPassword", "NewPassword1"); requestFormValues.Add("GovUk_Text_ConfirmNewPassword", "NewPassword1"); var controller = new ControllerBuilder <ChangePasswordController>() .WithLoggedInUser(user) .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); // Act controller.ChangePasswordPost(new ChangePasswordViewModel()); // Assert bool isExpectedPassword = mockUserRepo.CheckPassword(user, "NewPassword1"); Assert.IsTrue(isExpectedPassword); }
public void POST_Audit_Log_Item_Is_Saved_When_Password_Is_Successfully_Updated() { // Arrange User user = new UserBuilder().WithPassword("password").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_CurrentPassword", "password"); requestFormValues.Add("GovUk_Text_NewPassword", "NewPassword1"); requestFormValues.Add("GovUk_Text_ConfirmNewPassword", "NewPassword1"); var controllerBuilder = new ControllerBuilder <ChangePasswordController>(); var controller = controllerBuilder .WithLoggedInUser(user) .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); // Act controller.ChangePasswordPost(new ChangePasswordViewModel()); // Assert // Assert that exactly one audit log entry is added List <AuditLog> auditLogEntries = controllerBuilder.DataRepository.GetAll <AuditLog>().ToList(); Assert.AreEqual(1, auditLogEntries.Count); // Assert that the audit log entry audits the correct action Assert.AreEqual(AuditedAction.UserChangePassword, auditLogEntries.First().Action); }
public void ProcessRequestWithNormalControlFlowForAsynchronousController() { // 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); 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.Expect(c => c.Response.AppendHeader(MvcHandler.MvcVersionHeaderName, "1.0")).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 Area_RoutedByConvention() { ControllerBuilder.AddAttribute(MvcConstants.AreaAttributeFullName_AspNetCore) .AddStringConstructorArg("ThingsManagement").Commit(); AssertRouteEquals("/ThingsManagement/Things/RandoMethod"); }
public void POST_Providing_A_Valid_New_Email_Address_Results_In_A_Verification_Email_Being_Sent() { // Arrange User user = new UserBuilder().WithEmailAddress("*****@*****.**").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_NewEmailAddress", "*****@*****.**"); var controllerBuilder = new ControllerBuilder <ChangeEmailController>(); var controller = controllerBuilder .WithLoggedInUser(user) .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); // Act controller.ChangeEmailPost(new ChangeEmailViewModel()); // Assert Assert.AreEqual(1, controllerBuilder.EmailsSent.Count); var email = controllerBuilder.EmailsSent.FirstOrDefault(); Assert.NotNull(email); Assert.AreEqual(EmailTemplates.SendChangeEmailPendingVerificationEmail, email.TemplateId); Assert.AreEqual("*****@*****.**", email.EmailAddress); }
protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state) { AddVersionHeader(httpContext); // Get the controller type string controllerName = RequestContext.RouteData.GetRequiredString("controller"); // Instantiate the controller and call Execute IControllerFactory factory = ControllerBuilder.GetControllerFactory(); IController controller = factory.CreateController(RequestContext, controllerName); if (controller == null) { throw new InvalidOperationException( String.Format( CultureInfo.CurrentUICulture, MvcResources.ControllerBuilder_FactoryReturnedNull, factory.GetType(), controllerName)); } BeginExecuteDelegate beginExecute; EndExecuteDelegate endExecute; IAsyncController asyncController = controller as IAsyncController; if (asyncController != null) { beginExecute = asyncController.BeginExecute; endExecute = asyncController.EndExecute; } else { // execute synchronous controller asynchronously ExecuteDelegate executeDelegate = rc => SynchronizationContext.Sync(() => controller.Execute(rc)); beginExecute = executeDelegate.BeginInvoke; endExecute = executeDelegate.EndInvoke; } BeginInvokeCallback beginCallback = (innerCallback, innerState) => { try { return(beginExecute(RequestContext, innerCallback, innerState)); } catch { factory.ReleaseController(controller); throw; } }; AsyncCallback endCallback = ar => { try { endExecute(ar); } finally { factory.ReleaseController(controller); } }; return(AsyncResultWrapper.Wrap(callback, state, beginCallback, endCallback, _processRequestTag)); }
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.False(rd.Values.ContainsKey("optional")); }
public void POST_Verification_Email_Is_Sent_After_Creating_User_Account() { // Arrange var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_EmailAddress", "*****@*****.**"); requestFormValues.Add("GovUk_Text_ConfirmEmailAddress", "*****@*****.**"); requestFormValues.Add("GovUk_Text_FirstName", "Test"); requestFormValues.Add("GovUk_Text_LastName", "Example"); requestFormValues.Add("GovUk_Text_JobTitle", "Tester"); requestFormValues.Add("GovUk_Text_Password", "Pa55word"); requestFormValues.Add("GovUk_Text_ConfirmPassword", "Pa55word"); requestFormValues.Add("GovUk_Checkbox_SendUpdates", "true"); requestFormValues.Add("GovUk_Checkbox_AllowContact", "false"); var controllerBuilder = new ControllerBuilder <AccountCreationController>(); var controller = controllerBuilder .WithRequestFormValues(requestFormValues) .WithMockUriHelper() .Build(); // Act var response = (ViewResult)controller.CreateUserAccountPost(new CreateUserAccountViewModel()); // Assert Assert.AreEqual("ConfirmEmailAddress", response.ViewName); Assert.AreEqual(1, controllerBuilder.EmailsSent.Count); NotifyEmail emailSent = controllerBuilder.EmailsSent[0]; Assert.AreEqual("*****@*****.**", emailSent.EmailAddress); Assert.AreEqual(EmailTemplates.AccountVerificationEmail, emailSent.TemplateId); }
public void CreateControllerWithFactoryThatThrowsDoesNothingSpecial() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(ControllerFactoryThrows)); // Act Assert.Throws <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 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 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 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 Assert.Throws <Exception>( delegate { handler.ProcessRequest(requestContext.HttpContext); }, "some exception"); // Assert mockController.Verify(); contextMock.Verify(); mockController.As <IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce()); }
public void POST_Cannot_Update_Email_Address_For_Non_Active_User() { // Arrange User user = new UserBuilder().DefaultRetiredUser().WithEmailAddress("*****@*****.**").WithPassword("password").Build(); var requestFormValues = new Dictionary <string, StringValues>(); requestFormValues.Add("GovUk_Text_Password", "password"); var controllerBuilder = new ControllerBuilder <ChangeEmailController>(); var controller = controllerBuilder .WithLoggedInUser(user) .WithRequestFormValues(requestFormValues) .WithDatabaseObjects(user) .WithMockUriHelper() .Build(); var emailVerificationCode = Encryption.EncryptModel( new ChangeEmailVerificationToken { UserId = user.UserId, NewEmailAddress = "*****@*****.**".ToLower(), TokenTimestamp = VirtualDateTime.Now }); var viewModel = new VerifyEmailChangeViewModel { NewEmailAddress = "*****@*****.**", Code = emailVerificationCode, User = user }; // Act & Assert Assert.Throws <ArgumentException>(() => controller.VerifyEmailPost(viewModel)); }
public void CreateControllerWithFactoryThatCannotBeCreatedThrows() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(ControllerFactoryThrowsFromConstructor)); // Act Assert.Throws <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 static void ScaffoldEntities(string srcDirectory, string testDirectory, string projectBaseName, List <Entity> entities, string dbContextName, bool addSwaggerComments, IFileSystem fileSystem) { foreach (var entity in entities) { // not worrying about DTOs, profiles, validators, fakers - they are all added by default EntityBuilder.CreateEntity(srcDirectory, entity, projectBaseName, fileSystem); DtoBuilder.CreateDtos(srcDirectory, entity, projectBaseName); ValidatorBuilder.CreateValidators(srcDirectory, projectBaseName, entity); ProfileBuilder.CreateProfile(srcDirectory, entity, projectBaseName); ApiRouteModifier.AddRoutes(testDirectory, entity, projectBaseName); // api routes always added to testing by default. too much of a pain to scaffold if (entity.Features.Count > 0) { ControllerBuilder.CreateController(srcDirectory, entity.Name, entity.Plural, projectBaseName); } // TODO refactor to factory? foreach (var feature in entity.Features) { AddFeatureToProject(srcDirectory, testDirectory, projectBaseName, dbContextName, addSwaggerComments, feature.Policies, feature, entity, fileSystem); } // Shared Tests FakesBuilder.CreateFakes(testDirectory, projectBaseName, entity); } }
public void GET_Clicking_Link_In_Verification_Email_Confirms_User() { // Arrange var user = new User { UserId = 1, EmailAddress = "*****@*****.**", Firstname = "Test", Lastname = "Example", EmailVerifySendDate = VirtualDateTime.Now, EmailVerifyHash = Guid.NewGuid().ToString("N"), Status = UserStatuses.New }; var controller = new ControllerBuilder <AccountCreationController>() .WithDatabaseObjects(user) .Build(); // Act var response = (RedirectToActionResult)controller.VerifyEmail(user.EmailVerifyHash); // Assert Assert.AreEqual("AccountCreationConfirmation", response.ActionName); Assert.AreEqual(user.Status, UserStatuses.Active); }
public void ControllerBuilderReturnsDefaultControllerBuilderByDefault() { // Arrange ControllerBuilder cb = new ControllerBuilder(); // Act IControllerFactory cf = cb.GetControllerFactory(); // Assert Assert.IsType<DefaultControllerFactory>(cf); }
public void Should_be_able_to_register_controller_factory() { var builder = new ControllerBuilder(); var registration = new RegisterControllerFactory(builder); var serviceLocator = new Mock<FakeServiceLocator>(); var controllerFactory = new Mock<IControllerFactory>(); serviceLocator.Setup(sl => sl.GetInstance<IControllerFactory>()).Returns(controllerFactory.Object); registration.Execute(serviceLocator.Object); Assert.Same(controllerFactory.Object, builder.GetControllerFactory()); }
public void CreateControllerWithFactoryThatReturnsNullThrows() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(ControllerFactoryReturnsNull)); // Act Assert.Throws<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 CreateControllerWithFactoryThatCannotBeCreatedThrows() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(ControllerFactoryThrowsFromConstructor)); // Act Assert.Throws<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 CreateControllerWithFactoryThatThrowsDoesNothingSpecial() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(ControllerFactoryThrows)); // Act Assert.Throws<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 CreateControllerWithFactoryInstanceReturnsInstance() { // Arrange ControllerBuilder cb = new ControllerBuilder(); DefaultControllerFactory factory = new DefaultControllerFactory(); cb.SetControllerFactory(factory); // Act IControllerFactory cf = cb.GetControllerFactory(); // Assert Assert.Same(factory, cf); }
public void SettingControllerFactoryReturnsSetFactory() { // Arrange ControllerBuilder builder = new ControllerBuilder(); Mock<IControllerFactory> setFactory = new Mock<IControllerFactory>(); // Act builder.SetControllerFactory(setFactory.Object); // Assert Assert.Same(setFactory.Object, builder.GetControllerFactory()); }
public void ControllerBuilderGetControllerFactoryDelegatesToResolver() { //Arrange Mock<IControllerFactory> factory = new Mock<IControllerFactory>(); Resolver<IControllerFactory> resolver = new Resolver<IControllerFactory> { Current = factory.Object }; ControllerBuilder builder = new ControllerBuilder(resolver); //Act IControllerFactory result = builder.GetControllerFactory(); //Assert Assert.Same(factory.Object, result); }
public void DefaultControllerFactoryIsDefaultControllerFactory() { // Arrange ControllerBuilder builder = new ControllerBuilder(); // Act IControllerFactory returnedControllerFactory = builder.GetControllerFactory(); //Assert Assert.Equal(typeof(DefaultControllerFactory), returnedControllerFactory.GetType()); }
public void SetControllerFactoryTypeWithNonFactoryTypeThrows() { ControllerBuilder cb = new ControllerBuilder(); Assert.Throws<ArgumentException>( 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(); Assert.ThrowsArgumentNull( delegate { cb.SetControllerFactory((Type)null); }, "controllerFactoryType"); }
public AccountController(ControllerBuilder cb) : base(cb) { }
public void CreateControllerWithFactoryTypeReturnsValidType() { // Arrange ControllerBuilder cb = new ControllerBuilder(); cb.SetControllerFactory(typeof(MockControllerFactory)); // Act IControllerFactory cf = cb.GetControllerFactory(); // Assert Assert.IsType<MockControllerFactory>(cf); }
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 Assert.Throws<Exception>( delegate { handler.ProcessRequest(requestContext.HttpContext); }, "some exception"); // Assert mockController.Verify(); contextMock.Verify(); mockController.As<IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce()); }
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 }; }
/// <summary> /// Initializes a new instance of the <see cref="RegisterControllerFactory"/> class. /// </summary> /// <param name="controllerBuilder">The controller builder.</param> public RegisterControllerFactory(ControllerBuilder controllerBuilder) { Invariant.IsNotNull(controllerBuilder, "controllerBuilder"); ControllerBuilder = controllerBuilder; }
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 LoginController(ControllerBuilder cb, AccountService sAccount) : base(cb) { _sAccount = sAccount; }
static ControllerBuilder() { Current = new ControllerBuilder(); }
private static DefaultControllerFactory GetDefaultControllerFactory(params string[] namespaces) { ControllerBuilder builder = new ControllerBuilder(); builder.DefaultNamespaces.UnionWith(namespaces); return new DefaultControllerFactory() { ControllerBuilder = builder }; }
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.False(rd.Values.ContainsKey("optional")); }