public async Task DeleteMembership_ShouldDeleteMembership()
{
// Arrange
const int membershipId = 1;
Mock <IMediator> mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(m => m.Send(It.IsAny <MembershipExistsQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
mediatorMock
.Setup(m => m.Send(It.IsAny <CanDeleteMembershipQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true);
DeleteMembershipCommand passedDeleteCommand = null;
mediatorMock
.Setup(m => m.Send(It.IsAny <DeleteMembershipCommand>(), It.IsAny <CancellationToken>()))
.Callback <IRequest <Unit>, CancellationToken>((r, _) => passedDeleteCommand = (DeleteMembershipCommand)r)
.ReturnsAsync(Unit.Value);
GroupMembershipController controller = new GroupMembershipController(mediatorMock.Object, null);
// Act
ActionResult response = await controller.DeleteMembership(membershipId);
// Assert
Assert.IsType <NoContentResult>(response);
mediatorMock.Verify(m => m.Send(It.IsAny <DeleteMembershipCommand>(), It.IsAny <CancellationToken>()), Times.Once);
Assert.NotNull(passedDeleteCommand);
Assert.Equal(membershipId, passedDeleteCommand.GroupMembershipId);
}
public async Task <IActionResult> DeleteMembership([FromRoute] int id)
{
var command = new DeleteMembershipCommand(id);
var result = await _mediator.Send(command);
return(Ok($"Membership [MembershipId: {result.MembershipId}] has been deleted"));
}
public async Task DeleteMembershipCommandHandler_ShouldDeleteMembership_WhenItIsForeignMembership()
{
// Arrange
DeleteMembershipCommand request = new DeleteMembershipCommand {
GroupMembershipId = 1
};
IQueryable <GroupMembership> expectedMembership = new[]
{
new GroupMembership {
GroupMembershipId = 1, UserId = 2
}
}
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.GroupMemberships.GetById(1))
.Returns(expectedMembership);
GroupMembership passedMembership = null;
_unitOfWorkMock
.Setup(m => m.GroupMemberships.Delete(It.IsAny <GroupMembership>()))
.Callback <GroupMembership>(gm => passedMembership = gm);
_unitOfWorkMock
.Setup(m => m.CommitAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(1);
DeleteMembershipCommand.Handler handler = new DeleteMembershipCommand.Handler(_unitOfWorkMock.Object, _userProviderMock.Object);
// Act
await handler.Handle(request);
// Assert
_unitOfWorkMock.Verify(m => m.GroupMemberships.Delete(It.IsAny <GroupMembership>()), Times.Once);
_unitOfWorkMock.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce);
Assert.NotNull(passedMembership);
Assert.Equal(request.GroupMembershipId, passedMembership.GroupMembershipId);
}
public async Task <ActionResult> DeleteMembership([FromRoute] int membershipId, CancellationToken cancellationToken = default)
{
// Check if the membership exists
MembershipExistsQuery existsQuery = new MembershipExistsQuery {
GroupMembershipId = membershipId
};
bool exists = await _mediator.Send(existsQuery, cancellationToken);
if (!exists)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Membership with ID '{membershipId}' does not exist"
}));
}
// Check if the user is permitted to delete
CanDeleteMembershipQuery canDeleteQuery = new CanDeleteMembershipQuery {
GroupMembershipIdToDelete = membershipId
};
bool canDelete = await _mediator.Send(canDeleteQuery, cancellationToken);
if (!canDelete)
{
return(StatusCode(StatusCodes.Status403Forbidden, new ErrorResource
{
StatusCode = StatusCodes.Status403Forbidden,
Message = "You are not permitted to delete users from this group. This privilege is only granted to administrators of the group"
}));
}
// Delete the membership
DeleteMembershipCommand deleteCommand = new DeleteMembershipCommand {
GroupMembershipId = membershipId
};
await _mediator.Send(deleteCommand, cancellationToken);
return(NoContent());
}
public async Task DeleteMembershipCommandHandler_ShouldDeleteMembership_AndDeleteGroup_WhenTheUserLeavesByHimselfAndThereAreNoOtherMembersInTheGroup()
{
// Arrange
DeleteMembershipCommand request = new DeleteMembershipCommand {
GroupMembershipId = 1
};
IQueryable <GroupMembership> expectedMembership = new[]
{
new GroupMembership {
GroupMembershipId = 1, UserId = 1, GroupId = 1
}
}
.AsQueryable()
.BuildMock()
.Object;
IQueryable <GroupMembership> expectedMembershipsOfGroup = new[]
{
new GroupMembership {
GroupMembershipId = 1, UserId = 1, GroupId = 1
},
}
.AsQueryable()
.BuildMock()
.Object;
IQueryable <Group> expectedGroup = new[]
{
new Group {
GroupId = 1
},
}
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.GroupMemberships.GetById(1))
.Returns(expectedMembership);
_unitOfWorkMock
.Setup(m => m.GroupMemberships.GetByGroup(1))
.Returns(expectedMembershipsOfGroup);
_unitOfWorkMock
.Setup(m => m.Groups.GetById(1))
.Returns(expectedGroup);
Group passedUpdateGroup = null;
_unitOfWorkMock
.Setup(m => m.Groups.Update(It.IsAny <Group>()))
.Callback <Group>(g => passedUpdateGroup = g);
GroupMembership passedDeleteMembership = null;
_unitOfWorkMock
.Setup(m => m.GroupMemberships.Delete(It.IsAny <GroupMembership>()))
.Callback <GroupMembership>(gm => passedDeleteMembership = gm);
_unitOfWorkMock
.Setup(m => m.CommitAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(1);
DeleteMembershipCommand.Handler handler = new DeleteMembershipCommand.Handler(_unitOfWorkMock.Object, _userProviderMock.Object);
// Act
await handler.Handle(request);
// Assert
_unitOfWorkMock.Verify(m => m.Groups.Update(It.IsAny <Group>()));
Assert.NotNull(passedUpdateGroup);
Assert.Equal(1, passedUpdateGroup.GroupId);
Assert.True(passedUpdateGroup.IsDeleted);
_unitOfWorkMock.Verify(m => m.GroupMemberships.Delete(It.IsAny <GroupMembership>()), Times.Once);
_unitOfWorkMock.Verify(m => m.CommitAsync(It.IsAny <CancellationToken>()), Times.AtLeastOnce);
Assert.NotNull(passedDeleteMembership);
Assert.Equal(request.GroupMembershipId, passedDeleteMembership.GroupMembershipId);
}
