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"));
}
