public async Task DeletePermission_InovokeMethods()
{
await _service.DeletePermission(new Permission());
_permissionRepositoryMock.Verify(c => c.DeleteAsync(It.IsAny <Permission>()), Times.Once);
_cacheMock.Verify(c => c.RemoveByPrefix(It.IsAny <string>(), It.IsAny <bool>()), Times.Once);
}
public void Permission_DeletePermission_Pass()
{
//Arrange
var aString = "Rate Show";
var permission = new Permission(aString);
var context = new BroadwayBuilderContext();
var permissionService = new PermissionService(context);
var expected = true;
var actual = false;
//Act
permissionService.CreatePermission(permission);
context.SaveChanges();
permissionService.DeletePermission(permission);
var save = context.SaveChanges();
if (save > 0)
{
actual = true;
}
//Assert
Assert.AreEqual(expected, actual);
}
public async Task DeletePermission_PermissionFound_Should_DeletePermission()
{
// Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var permissionRepositoryMock = new Mock <IPermissionRepository>();
var mapperMock = new Mock <IMapper>();
const int permissionId = 1;
var permission = new Permission
{
Id = permissionId,
Name = "Permission1"
};
var service = new PermissionService(unitOfWorkMock.Object, mapperMock.Object);
permissionRepositoryMock.Setup(v => v.ExistAsync(It.IsAny <Expression <Func <Permission, bool> > >()))
.ReturnsAsync(true);
permissionRepositoryMock.Setup(x => x.GetByIdAsync(permissionId, It.IsAny <IEnumerable <string> >()))
.ReturnsAsync(permission);
unitOfWorkMock.Setup(v => v.PermissionRepository)
.Returns(permissionRepositoryMock.Object);
// Act
await service.DeletePermission(permissionId);
// Assert
permissionRepositoryMock.Verify(x => x.DeleteAsync(permission));
unitOfWorkMock.Verify(x => x.SaveAsync());
}
public void AuthorizationService_UserHasPermission_Pass()
{
// Arrange
BroadwayBuilderContext broadwayBuilderContext = new BroadwayBuilderContext();
var username = "******";
var firstName = "Abi";
var lastName = "Castro";
int age = 24;
var dob = new DateTime(1994, 1, 7);
var city = "San Diego";
var stateProvince = "California";
var country = "United States";
var enable = true;
var user = new User(username, firstName, lastName, age, dob, city, stateProvince, country, enable);
var permission = new Permission("RateShow", true);
var theater = new Theater("someTheater", "Regal", "theater st", "LA", "CA", "US", "323323");
var expected = true;
var actual = false;
var service = new AuthorizationService(broadwayBuilderContext);
var userService = new UserService(broadwayBuilderContext);
var theaterService = new TheaterService(broadwayBuilderContext);
var permissionService = new PermissionService(broadwayBuilderContext);
//Adding data into tables
permissionService.CreatePermission(permission);
broadwayBuilderContext.SaveChanges();
userService.CreateUser(user);
broadwayBuilderContext.SaveChanges();
theaterService.CreateTheater(theater);
broadwayBuilderContext.SaveChanges();
userService.AddUserPermission(user, permission, theater);
broadwayBuilderContext.SaveChanges();
// Act
actual = service.HasPermission(user, permission, theater);
UserPermission userPermission = userService.GetUserPermission(user, permission, theater);
userService.DeleteUserPermission(userPermission);
broadwayBuilderContext.SaveChanges();
userService.DeleteUser(user);
permissionService.DeletePermission(permission);
theaterService.DeleteTheater(theater);
broadwayBuilderContext.SaveChanges();
// Assert
Assert.AreEqual(expected, actual);
}
public void TestDeletePermission()
{
//Arrange
Permission ToDelete = permissionService.GetPermissions().FirstOrDefault();
//Act
permissionService.DeletePermission(ToDelete);
//Assert
Assert.IsNull(permissionService.GetById(ToDelete.PermissionId));
}
public IHttpActionResult DeletePermission(int id)
{
try
{
string accessToken = Request.Headers.Authorization == null ? null : Request.Headers.Authorization.Parameter;
string msg = _service.DeletePermission(id, accessToken);
return(Content(HttpStatusCode.OK, msg));
}
catch (Exception ex)
{
Logger.WriteException("DeletePermission : ", ex);
return(Content(HttpStatusCode.BadRequest, ex.GetBaseException().Message));
}
}
public void DeletePermission_PermissionNotFound_Should_ThrowsNotFoundException()
{
// Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var permissionRepositoryMock = new Mock <IPermissionRepository>();
var service = new PermissionService(unitOfWorkMock.Object, null);
permissionRepositoryMock.Setup(v => v.ExistAsync(It.IsAny <Expression <Func <Permission, bool> > >()))
.ReturnsAsync(false);
unitOfWorkMock.Setup(v => v.PermissionRepository)
.Returns(permissionRepositoryMock.Object);
// Act => Assert
Assert.ThrowsAsync <NotFoundException>(() => service.DeletePermission(1), "The permission doesn't exist");
}
public void PermissionService_GetPermission_Pass()
{
//Arrange
var aString = "RateShow";
var permission = new Permission(aString, true);
var context = new BroadwayBuilderContext();
var permissionService = new PermissionService(context);
var expected = true;
var actual = false;
//Act
permissionService.CreatePermission(permission);
context.SaveChanges();
Permission getPermission = permissionService.GetPermission(permission.PermissionID);
if (getPermission != null)
{
actual = true;
}
permissionService.DeletePermission(permission);
context.SaveChanges();
//Assert
Assert.AreEqual(expected, actual);
}
private async Task AddDefaultRoleAndPermissionAsync(Client client)
{
try
{
var newPermission = await _permissionService.AddPermission(new Permission
{
Name = Domain.Defaults.Authorization.ManageAuthorizationPermissionName,
Grain = Domain.Defaults.Authorization.AppGrain,
SecurableItem = client.TopLevelSecurableItem.Name
});
try
{
await _roleService.AddRole(new Role
{
Name = $"{client.Id}-admin",
Grain = Domain.Defaults.Authorization.AppGrain,
SecurableItem = client.TopLevelSecurableItem.Name,
Permissions = new List <Permission> {
newPermission
}
});
}
catch (Exception)
{
//if we can't create the role, delete the client and the permission
await _clientService.DeleteClient(client);
await _permissionService.DeletePermission(newPermission);
throw;
}
}
catch (Exception)
{
//if we can't save the permission, delete the client and rethrow the exception
await _clientService.DeleteClient(client);
throw;
}
}
private async Task <dynamic> DeletePermission(dynamic parameters)
{
try
{
if (!Guid.TryParse(parameters.permissionId, out Guid permissionId))
{
return(CreateFailureResponse("permissionId must be a guid.", HttpStatusCode.BadRequest));
}
Permission permission = await _permissionService.GetPermission(permissionId);
await CheckAccess(_clientService, permission.Grain, permission.SecurableItem, AuthorizationWriteClaim);
await _permissionService.DeletePermission(permission);
return(HttpStatusCode.NoContent);
}
catch (NotFoundException <Permission> ex)
{
Logger.Error(ex, ex.Message, parameters.permissionId);
return(CreateFailureResponse($"The specified permission with id: {parameters.permissionId} was not found",
HttpStatusCode.NotFound));
}
}
public void PermissionService_GetPermission_Pass()
{
//Arrange
var aString = "RateShow";
var permission = new Permission(aString, true);
var context = new BroadwayBuilderContext();
var permissionService = new PermissionService(context);
var expected = true;
var actual = false;
//Act
Permission getPermission = permissionService.GetPermission(DataAccessLayer.Enums.PermissionsEnum.ActivateAbusiveAccount);
if (getPermission != null)
{
actual = true;
}
permissionService.DeletePermission(permission);
context.SaveChanges();
//Assert
Assert.AreEqual(expected, actual);
}
public async void RemoveUserButtonClick(ReadUser user)
{
if (ActiveUser.IsActive == true)
{
bool succ = await PermissionService.DeletePermission(ActiveUser.Instance.LoggedUser.Token,
parentBoardId, user.username);
if (succ)
{
ShowMessageBox(null, "Obrisan user");
ReadUser u = Users.FirstOrDefault(x => x.username == user.username);
Users.Remove(u);
}
else
{
ShowMessageBox(null, "Error deleting user.");
}
}
else
{
ShowMessageBox(null, "Error getting user.");
}
}
public async Task PermissionService_DeletePermission_SuccessfulAsync()
{
var existingPermission = new Permission
{
Id = Guid.NewGuid(),
Grain = "app",
SecurableItem = "patientsafety",
Name = "manageusers"
};
var mockPermissionStore = new Mock <IPermissionStore>()
.SetupGetPermissions(new List <Permission> {
existingPermission
});
var mockRoleStore = new Mock <IRoleStore>().Object;
var permissionService = new PermissionService(
mockPermissionStore.Object,
new Mock <RoleService>(mockRoleStore, mockPermissionStore.Object).Object);
await permissionService.DeletePermission(existingPermission);
mockPermissionStore.Verify();
}
public async Task DeletePermissionReturnsCorrectType()
{
var permission = await _testPermissionService.DeletePermission(_testPermissions[0].UserId);
permission.Should().BeOfType <Permission>();
}
public bool Delete(int boardId, string username)
{
return(ps.DeletePermission(boardId, username, User.Identity.Name));
}
