public void ShouldCreateInstance_NotNull_Success()
{
_mockConfigurationRoot.SetupGet(x => x[It.IsAny <string>()]).Returns("the string you want to return");
var controller = new PermissionsController(_mockConfigurationRoot.Object);
Assert.NotNull(controller);
}
private PermissionsController ConfigureController()
{
//Mocking the user claims
var claims = new List <Claim> {
new Claim("CreatedOn", DateTime.UtcNow.ToString()),
new Claim("Email", "*****@*****.**"),
new Claim("Initials", "JD"),
new Claim("Name", "John Doe"),
new Claim("Role", "Admin"),
new Claim("UserId", Guid.NewGuid().ToString()),
new Claim("Username", "SomeUserName"),
new Claim("IsAuthenticated", "True")
};
var userIdentity = new ClaimsIdentity(claims, "Auth");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
var controller = new PermissionsController(_bosIAClient)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = principal
}
}
};
return(controller);
}
private PermissionsController ConfigureController()
{
//Mocking the user claims
var claims = new List <Claim> {
new Claim("CreatedOn", DateTime.UtcNow.ToString()),
new Claim("Email", "*****@*****.**"),
new Claim("Initials", "JD"),
new Claim("Name", "John Doe"),
new Claim("Role", "Admin"),
new Claim("UserId", Guid.NewGuid().ToString()),
new Claim("Username", "SomeUserName"),
new Claim("IsAuthenticated", "True")
};
var userIdentity = new ClaimsIdentity(claims, "Auth");
ClaimsPrincipal principal = new ClaimsPrincipal(userIdentity);
//Mocking a session
MockHttpSession mockSession = new MockHttpSession();
mockSession["Key"] = "KeySession";
var controller = new PermissionsController(_configuration, _contextAccessor)
{
ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = principal, Session = mockSession
}
}
};
return(controller);
}
public async Task GetPermissionAsync_WithTestGuid_ReturnsCorrectResult()
{
// Arrange
var permissionService = Substitute.For <IPermissionService>();
var testGuid = Guid.NewGuid();
var testName = "TestUserName";
permissionService.GetByIdAsync(testGuid).Returns(new Permission {
Uuid = testGuid, Name = testName
});
var controller = new PermissionsController(permissionService);
// Act
IActionResult actionResult = await controller.GetPermissionAsync(testGuid);
// Assert
var okResult = actionResult as OkObjectResult;
Assert.NotNull(okResult);
var permission = okResult.Value as Permission;
Assert.NotNull(permission);
Assert.True(permission.Uuid == testGuid, $"Retrieved Id {permission.Uuid} not the same as sample id {testGuid}.");
Assert.True(permission.Name == testName, $"Retrieved Name {permission.Name} not the same as sample id {testName}.");
}
protected override void OnDeactivated()
{
base.OnDeactivated();
PermissionsController permissionsController = Frame.GetController <PermissionsController>();
permissionsController.CollectDescendantPermissionTypes -= permissionsController_CollectCreatablePermissionTypes;
}
public void TestSeleccionarPerfilNotNull()
{
Init("*****@*****.**");
CurrentUser.setCurrentUser("*****@*****.**", "Superusuario", "0000000001", "0000000001");
PermissionsController controller = new PermissionsController();
Assert.IsNotNull(controller.SeleccionarPerfil());
}
public Resources()
{
IConfiguration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
DbContext = TestHelper.CreateDbContext(IConfiguration);
GuiController = new PermissionsController(DbContext);
}
public void TestCargarCheckboxesNull()
{
PermissionsController controller = new PermissionsController();
JsonResult checkboxes = controller.CargarCheckboxes(null, null, "0000000001", "0000000001");
string result = new JavaScriptSerializer().Serialize(checkboxes.Data);
string expected = "{\"persons\":\"\",\"permissions\":\"\"}";
Assert.AreEqual(result, expected);
}
public Resources()
{
Username = "******";
MockApiCaller = new MockApiCaller();
MockCookieHelper = new Mock <ICookieHelper>();
MockCookieHelper.Setup(x => x.GetCookie <UserModel>("LoggedInUser")).Returns(new UserModel {
Username = Username, ApiSessionToken = Guid.NewGuid().ToString(), IsAuthenticated = true
});
Controller = new PermissionsController(MockApiCaller, MockCookieHelper.Object);
}
public PermissionsControllerTests()
{
_permissionsRepositoryMock = new Mock <IPermissionsRepository>();
_doorsRepositoryMock = new Mock <IDoorsRepository>();
_controller = new PermissionsController(
_permissionsRepositoryMock.Object,
_doorsRepositoryMock.Object,
TestMapper.Instance.Value);
}
public void TestGuardarSeleccion()
{
Init("*****@*****.**");
PermissionsController controller = new PermissionsController();
CurrentUser.setCurrentUser("*****@*****.**", "Estudiante", "0000000001", "0000000001");
controller.GuardarSeleccion("Profesor", "0000000001", "0000000001");
Assert.AreEqual(CurrentUser.getUserProfile(), "Profesor");
Assert.AreEqual(CurrentUser.getUserMajorId(), "0000000001");
Assert.AreEqual(CurrentUser.getUserEmphasisId(), "0000000001");
}
public void TestCargarEnfasisDeCarrera()
{
Init("*****@*****.**");
CurrentUser.setCurrentUser("*****@*****.**", "Superusuario", "0000000001", "0000000001");
PermissionsController controller = new PermissionsController();
JsonResult json = controller.CargarEnfasisDeCarrera("0000000001");
string result = new JavaScriptSerializer().Serialize(json.Data);
string expected = "{\"data\":[\"0000000000,Tronco Común\",\"0000000001,Ingeniería de Software\",\"0000000002,Ciencias de la Computación\",\"0000000003,Tecnologías de la Información\"]}";
Assert.AreEqual(result, expected);
}
public void TestCargarUsuariosPermisos()
{
Init("*****@*****.**");
PermissionsController controller = new PermissionsController();
CurrentUser.setCurrentUser("*****@*****.**", "Superusuario", "0000000001", "0000000001");
JsonResult checkboxes = controller.CargarCheckboxes("8", CurrentUser.getUserProfile(), "0000000001", "0000000001");
string result = new JavaScriptSerializer().Serialize(checkboxes.Data);
Assert.IsNotNull(result);
}
public void TestCargarPerfil()
{
Init("*****@*****.**");
PermissionsController controller = new PermissionsController();
CurrentUser.setCurrentUser("*****@*****.**", "Superusuario", "0000000001", "0000000001");
JsonResult perfiles = controller.CargarPerfil();
string test = "{\"data\":[\"Superusuario\"]}";
string result = new JavaScriptSerializer().Serialize(perfiles.Data);
Assert.AreEqual(test, result);
}
public async Task GetPermissionAsync_WithRandomGuid_ReturnsNotFoundResult()
{
// Arrange
var permissionService = Substitute.For <IPermissionService>();
var controller = new PermissionsController(permissionService);
// Act
var result = await controller.GetPermissionAsync(Guid.NewGuid());
// Assert
Assert.IsType <NotFoundResult>(result);
}
public void ContentEditorControllerTest_Actions_Secured_By_Permissions()
{
//Arrange
var backOfficeRequestContext = GetBackOfficeRequestContext();
var controller = new ContentEditorController(backOfficeRequestContext);
controller.InjectDependencies(GetBackOfficeRequestContext());
//TODO: There may be a better way of automatically getting a single controller variable using the controller extenders,
//but likely that's just testing the action invoker, so for now here's the individual controllers
var copyController = new MoveCopyController(backOfficeRequestContext);
copyController.InjectDependencies(GetBackOfficeRequestContext());
var sortController = new SortController(backOfficeRequestContext);
sortController.InjectDependencies(GetBackOfficeRequestContext());
var publishController = new PublishController(backOfficeRequestContext);
publishController.InjectDependencies(GetBackOfficeRequestContext());
var hos = new HostnameController(backOfficeRequestContext);
hos.InjectDependencies(GetBackOfficeRequestContext());
var rollback = new RollbackController(backOfficeRequestContext);
rollback.InjectDependencies(GetBackOfficeRequestContext());
var permissions = new PermissionsController(backOfficeRequestContext);
permissions.InjectDependencies(GetBackOfficeRequestContext());
//Assert
Assert.IsTrue(ActionIsSecuredByPermission(controller, "CreateNew", FixedPermissionIds.Create));
Assert.IsTrue(ActionIsSecuredByPermission(controller, "Edit", FixedPermissionIds.Update));
Assert.IsTrue(ActionIsSecuredByPermission(controller, "Delete", FixedPermissionIds.Delete));
Assert.IsTrue(ActionIsSecuredByPermission(copyController, "Copy", FixedPermissionIds.Copy));
Assert.IsTrue(ActionIsSecuredByPermission(copyController, "Move", FixedPermissionIds.Move));
Assert.IsTrue(ActionIsSecuredByPermission(sortController, "Sort", FixedPermissionIds.Sort));
Assert.IsTrue(ActionIsSecuredByPermission(publishController, "Publish", FixedPermissionIds.Publish));
Assert.IsTrue(ActionIsSecuredByPermission(permissions, "Permissions", FixedPermissionIds.Permissions));
Assert.IsTrue(ActionIsSecuredByPermission(rollback, "Rollback", FixedPermissionIds.Rollback));
// TODO: (APN @ Matt) the assertion for action name doesn't take into account two methods with the same name
// but differing parameter counts, so this one fails
// NOTE: (MPB) Have renamed post action to HostnameForm to get test passing for now, not sure if that is enough
// or whether assertion method should allow you to query for a specific method signature?
Assert.IsTrue(ActionIsSecuredByPermission(hos, "Hostname", FixedPermissionIds.Hostnames));
}
public async Task UpdatePermissions_returns_error_string_when_data_is_null()
{
//Arrange
var controller = new PermissionsController(_configuration, _contextAccessor);
//Act
var result = await controller.UpdatePermissions(null);
//Assert
var messageResult = Assert.IsType <string>(result); //Asserting that the return is a String
Assert.Equal("Permission set cannot be empty", messageResult); //Asserting that message is equal as mentioned
}
public async Task FetchPermissions_returns_non_null_model_session_is_empty()
{
//Arrange
var controller = new PermissionsController(_configuration, _contextAccessor);
//Act
var result = await controller.FetchPermissions(Guid.NewGuid().ToString(), null);
//Assert
var viewResult = Assert.IsType <ViewResult>(result); //Asserting that the return is a View
dynamic model = Assert.IsAssignableFrom <ExpandoObject>(viewResult.ViewData.Model);
Assert.True(model.OwnerId != null);
}
public async Task GetPermissionAsync_WithEmptyGuid_ReturnsBadRequest()
{
// Arrange
var permissionService = Substitute.For <IPermissionService>();
var controller = new PermissionsController(permissionService);
// Act
var result = await controller.GetPermissionAsync(Guid.Empty);
// Assert
var badRequestResult = result as BadRequestResult;
Assert.NotNull(badRequestResult);
}
public void FetchPermissions_returns_model_with_null_currentmoduleid_when_session_is_empty()
{
//Arrange
var controller = new PermissionsController(_bosIAClient);
//Act
var result = controller.FetchPermissions(null, null);
//Assert
var viewResult = Assert.IsType <ViewResult>(result); //Asserting that the return is a View
dynamic model = Assert.IsAssignableFrom <ExpandoObject>(viewResult.ViewData.Model);
Assert.True(model.CurrentModuleId == null);
}
public async Task UpdatePermissions_returns_string_when_data_passed_is_incorrect()
{
//Arrange
var controller = new PermissionsController(_bosIAClient);
//Act
var result = await controller.UpdatePermissions(null);
//Assert
var redirectResult = Assert.IsType <RedirectToActionResult>(result); //Asserting that the return is a View
Assert.Equal("Roles", redirectResult.ControllerName); //Asseting that the returned Controller is "Role"
Assert.Equal("Index", redirectResult.ActionName); //Asseting that the Action Methond of the controller is "Index"
}
public RevokeTestsFixture()
{
RevokePermissionsRouteValues = new RevokePermissionsRouteValues(
ukprn: 299792458,
accountLegalEntityPublicHashedId: "DEADBEEF",
operationsToRevoke: new[] { Operation.Recruitment });
Mediator = new Mock <IMediator>();
Mediator
.Setup(x => x.Send(It.IsAny <RevokePermissionsCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(Unit.Value);
PermissionsController = new PermissionsController(Mediator.Object);
}
public void BackToRoles_returns_roles_view()
{
//Arrange
var controller = new PermissionsController(_configuration, _contextAccessor);
//Act
var result = controller.BackToRoles();
//Assert
var redirectResult = Assert.IsType <RedirectToActionResult>(result); //Asserting that the return is a View
Assert.Equal("Roles", redirectResult.ControllerName); //Asserting that the returned Controller is "Role"
Assert.Equal("Index", redirectResult.ActionName); //Asserting that the Action Methond of the controller is "Index"
}
public async Task UpdatePermissions_returns_error_string_when_modules_does_not_exist()
{
//Arrange
var controller = new PermissionsController(_configuration, _contextAccessor);
dynamic permissionObj = new ExpandoObject();
JObject data = JObject.FromObject(permissionObj);
//Act
var result = await controller.UpdatePermissions(data);
//Assert
var messageResult = Assert.IsType <string>(result); //Asserting that the return is a String
Assert.Contains("Object reference not set to an instance of an object", messageResult); //Asserting that message is equal as mentioned
}
public PermissionsPage()
{
InitializeComponent();
controller = new PermissionsController();
controller.Control();
comboBox.Items.Add("New Permission");
comboBox.SelectedIndex = 0;
LinkedList <string> perms = controller.GetPermissionsForComboBox();
foreach (string permission in perms)
{
comboBox.Items.Add(permission);
}
}
public void TestEntrarCargarUsuariosSinPermiso()
{
Init("*****@*****.**");
CurrentUser.setCurrentUser("*****@*****.**", "Estudiante", "0000000001", "0000000001");
PermissionsController controller = new PermissionsController();
RedirectToRouteResult result = controller.Index() as RedirectToRouteResult;
System.Web.Routing.RouteValueDictionary dictionary = new System.Web.Routing.RouteValueDictionary();
dictionary.Add("action", "Index");
dictionary.Add("controller", "Home");
RedirectToRouteResult expected = new RedirectToRouteResult(dictionary);
Assert.AreEqual(controller.TempData["alertmessage"], "No tiene permisos para acceder a esta página.");
Assert.AreEqual(result.RouteValues["action"], expected.RouteValues["action"]);
Assert.AreEqual(result.RouteValues["controller"], expected.RouteValues["controller"]);
}
public async Task UpdatePermissions_returns_error_string_when_modules_is_null()
{
//Arrange
var controller = new PermissionsController(_configuration, _contextAccessor);
dynamic permissionObj = new ExpandoObject();
permissionObj.Modules = null;
JObject data = JObject.FromObject(permissionObj);
//Act
var result = await controller.UpdatePermissions(data);
//Assert
var messageResult = Assert.IsType <string>(result); //Asserting that the return is a String
Assert.Contains("Value cannot be null", messageResult); //Asserting that message is equal as mentioned
}
public async Task UpdatePermissions_returns_error_string_when_data_passed_is_incorrect()
{
//Arrange
var controller = new PermissionsController(_configuration, _contextAccessor);
dynamic permissionObj = new ExpandoObject();
permissionObj.Modules = new List <PermissionsSet>();
permissionObj.Operations = new List <PermissionsOperation>();
permissionObj.OwnerId = Guid.NewGuid();
JObject data = JObject.FromObject(permissionObj);
//Act
var result = await controller.UpdatePermissions(data);
//Assert
var messageResult = Assert.IsType <string>(result); //Asserting that the return is a String
//Assert.Contains("Unrecognized Guid format", messageResult); //Asserting that message is equal as mentioned
}
public async Task ListPermissionsAsync_WithNoInputs_ReturnsList()
{
// Arrange
var permissionService = Substitute.For <IPermissionService>();
var inList = new List <Permission>();
inList.Add(new Permission {
Name = "Test Permissions 1", Uuid = Guid.NewGuid()
});
inList.Add(new Permission {
Name = "Test Permissions 2", Uuid = Guid.NewGuid()
});
inList.Add(new Permission {
Name = "Test Permissions 3", Uuid = Guid.NewGuid()
});
permissionService.GetListAsync().Returns(inList);
var controller = new PermissionsController(permissionService);
// Act
IActionResult actionResult = await controller.ListPermissionsAsync(0, 50, string.Empty, null);
// Assert
var okResult = actionResult as OkObjectResult;
Assert.NotNull(okResult);
var outList = okResult.Value as List <Permission>;
Assert.NotNull(outList);
for (var i = 0; i < outList.Count; i++)
{
Assert.Equal(outList[i].Uuid, inList[i].Uuid);
Assert.Equal(outList[i].Name, inList[i].Name);
}
}
public static void Populate(this DropDownList ddl, DropDownType type, string defaultSelectionValue = null, bool retainFirst = false)
{
switch (type)
{
case DropDownType.Role:
using (RolesController rc = new RolesController())
{
var roles = rc.Get().Select(i => new { Label = i.RoleName, Value = i.RoleID }).OrderBy(i => i.Label).ToList();
ddl.DataSource = roles;
}
break;
case DropDownType.ScopeType:
using (ScopesController sc = new ScopesController())
{
var scopes = sc.Get().Select(i => new { Label = i.ScopeName, Value = i.ScopeID }).OrderBy(i => i.Label).ToList();
ddl.DataSource = scopes;
}
break;
case DropDownType.Permission:
using (PermissionsController pc = new PermissionsController())
{
var permissions = pc.Get().Select(i => new { Label = i.PermissionName, Value = i.PermissionID }).OrderBy(i => i.Label).ToList();
ddl.DataSource = permissions;
}
break;
default: break;
}
Reset(ddl, retainFirst);
ddl.DataValueField = "Value";
ddl.DataTextField = "Label";
ddl.DataBind();
SelectDefault(ddl, defaultSelectionValue);
}
public void TestGuardarPermisosSinPermiso()
{
Init("*****@*****.**");
CurrentUser.setCurrentUser("*****@*****.**", "Estudiante", "0000000001", "0000000001");
var httpContext = new HttpContext(
new HttpRequest("", "http://localhost:44334/Home/Login", ""),
new HttpResponse(new StringWriter())
);
var tempData = new TempDataDictionary();
PermissionsController controller = new PermissionsController()
{
TempData = tempData
};
PermissionsViewHolder model = new PermissionsViewHolder();
RedirectToRouteResult result = controller.GuardarPermisos(model, false) as RedirectToRouteResult;
System.Web.Routing.RouteValueDictionary dictionary = new System.Web.Routing.RouteValueDictionary();
dictionary.Add("action", "../Home/Index");
RedirectToRouteResult expected = new RedirectToRouteResult(dictionary);
Assert.AreEqual(controller.TempData["alertmessage"], "No tiene permisos para acceder a esta página.");
Assert.AreEqual(result.RouteValues["action"], expected.RouteValues["action"]);
}
