leon.hoppe/HopFrame
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

added tests and documentation for group endpoints

Browse Source
This commit is contained in:
Leon Hoppe
2024-12-23 18:30:23 +01:00
parent 99d39be9ac
commit e613fa66e3
3 changed files with 616 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

369
tests/HopFrame.Tests.Api/Controllers/GroupControllerTests.cs Normal file
View File

@@ -0,0 +1,369 @@
using System.Net;
using HopFrame.Api.Controller;
using HopFrame.Api.Logic;
using HopFrame.Database.Models;
using HopFrame.Database.Repositories;
using HopFrame.Security.Authorization;
using HopFrame.Security.Claims;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Options;
using Moq;
namespace HopFrame.Tests.Api.Controllers;
public class GroupControllerTests {
private (Mock<IGroupLogic>, Mock<IOptions<AdminPermissionOptions>>, Mock<IPermissionRepository>, Mock<ITokenContext>
, GroupController) SetupEnvironment() {
var mockGroups = new Mock<IGroupLogic>();
var mockPermissions = new Mock<IOptions<AdminPermissionOptions>>();
var mockPerms = new Mock<IPermissionRepository>();
var mockContext = new Mock<ITokenContext>();
var options = new AdminPermissionOptions();
mockPermissions.Setup(o => o.Value).Returns(options);
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(true);
var controller = new GroupController(mockPermissions.Object, mockPerms.Object, mockContext.Object,
mockGroups.Object);
return (mockGroups, mockPermissions, mockPerms, mockContext, controller);
}
[Fact]
public async Task GetGroups_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.GetGroups();
// Assert
Assert.IsType<UnauthorizedResult>(result.Result);
}
[Fact]
public async Task GetGroups_ShouldReturnGroups_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
var groups = new List<PermissionGroup> { new PermissionGroup { Name = "testgroup" } };
mockGroups.Setup(g => g.GetGroups()).ReturnsAsync(LogicResult<IList<PermissionGroup>>.Ok(groups));
// Act
var result = await controller.GetGroups();
// Assert
var okResult = Assert.IsType<OkObjectResult>(result.Result);
var returnedGroups = Assert.IsAssignableFrom<IList<PermissionGroup>>(okResult.Value);
Assert.Single(returnedGroups);
Assert.Equal("testgroup", returnedGroups.First().Name);
}
[Fact]
public async Task GetDefaultGroups_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.GetDefaultGroups();
// Assert
Assert.IsType<UnauthorizedResult>(result.Result);
}
[Fact]
public async Task GetDefaultGroups_ShouldReturnGroups_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
var groups = new List<PermissionGroup> { new PermissionGroup { Name = "defaultgroup" } };
mockGroups.Setup(g => g.GetDefaultGroups()).ReturnsAsync(LogicResult<IList<PermissionGroup>>.Ok(groups));
// Act
var result = await controller.GetDefaultGroups();
// Assert
var okResult = Assert.IsType<OkObjectResult>(result.Result);
var returnedGroups = Assert.IsAssignableFrom<IList<PermissionGroup>>(okResult.Value);
Assert.Single(returnedGroups);
Assert.Equal("defaultgroup", returnedGroups.First().Name);
}
[Fact]
public async Task GetUserGroups_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.GetUserGroups("valid-user-id");
// Assert
Assert.IsType<UnauthorizedResult>(result.Result);
}
[Fact]
public async Task GetUserGroups_ShouldReturnGroups_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(true);
var groups = new List<PermissionGroup> { new PermissionGroup { Name = "usergroup" } };
mockGroups.Setup(g => g.GetUserGroups(It.IsAny<string>()))
.ReturnsAsync(LogicResult<IList<PermissionGroup>>.Ok(groups));
// Act
var result = await controller.GetUserGroups("valid-user-id");
// Assert
var okResult = Assert.IsType<OkObjectResult>(result.Result);
var returnedGroups = Assert.IsAssignableFrom<IList<PermissionGroup>>(okResult.Value);
Assert.Single(returnedGroups);
Assert.Equal("usergroup", returnedGroups.First().Name);
}
[Fact]
public async Task GetGroup_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.GetGroup("group-name");
// Assert
Assert.IsType<UnauthorizedResult>(result.Result);
}
[Fact]
public async Task GetGroup_ShouldReturnGroup_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(true);
var group = new PermissionGroup { Name = "group-name" };
mockGroups.Setup(g => g.GetGroup(It.IsAny<string>())).ReturnsAsync(LogicResult<PermissionGroup>.Ok(group));
// Act
var result = await controller.GetGroup("group-name");
// Assert
var okResult = Assert.IsType<OkObjectResult>(result.Result);
var returnedGroup = Assert.IsType<PermissionGroup>(okResult.Value);
Assert.Equal("group-name", returnedGroup.Name);
}
[Fact]
public async Task CreateGroup_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.CreateGroup(new PermissionGroup { Name = "newgroup" });
// Assert
Assert.IsType<UnauthorizedResult>(result.Result);
}
[Fact]
public async Task CreateGroup_ShouldReturnGroup_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(true);
var group = new PermissionGroup { Name = "newgroup" };
mockGroups.Setup(g => g.CreateGroup(It.IsAny<PermissionGroup>()))
.ReturnsAsync(LogicResult<PermissionGroup>.Ok(group));
// Act
var result = await controller.CreateGroup(new PermissionGroup { Name = "newgroup" });
// Assert
var okResult = Assert.IsType<OkObjectResult>(result.Result);
var createdGroup = Assert.IsType<PermissionGroup>(okResult.Value);
Assert.Equal("newgroup", createdGroup.Name);
}
[Fact]
public async Task UpdateGroup_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.UpdateGroup(new PermissionGroup { Name = "updategroup" });
// Assert
Assert.IsType<UnauthorizedResult>(result.Result);
}
[Fact]
public async Task UpdateGroup_ShouldReturnGroup_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(true);
var group = new PermissionGroup { Name = "updategroup" };
mockGroups.Setup(g => g.UpdateGroup(It.IsAny<PermissionGroup>()))
.ReturnsAsync(LogicResult<PermissionGroup>.Ok(group));
// Act
var result = await controller.UpdateGroup(new PermissionGroup { Name = "updategroup" });
// Assert
var okResult = Assert.IsType<OkObjectResult>(result.Result);
var updatedGroup = Assert.IsType<PermissionGroup>(okResult.Value);
Assert.Equal("updategroup", updatedGroup.Name);
}
[Fact]
public async Task DeleteGroup_ShouldReturnUnauthorized_WhenUserIsNotAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(false);
// Act
var result = await controller.DeleteGroup("group-name");
// Assert
Assert.IsType<UnauthorizedResult>(result);
}
[Fact]
public async Task DeleteGroup_ShouldReturnOk_WhenUserIsAuthorized() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockPerms.Setup(p => p.HasPermission(It.IsAny<User>(), It.IsAny<string>())).ReturnsAsync(true);
mockGroups.Setup(g => g.DeleteGroup(It.IsAny<string>())).ReturnsAsync(LogicResult.Ok());
// Act
var result = await controller.DeleteGroup("group-name");
// Assert
Assert.IsType<OkResult>(result);
}
[Fact]
public async Task GetUserGroups_ShouldReturnBadRequest_WhenUserIdIsInvalid() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.GetUserGroups(It.IsAny<string>()))
.ReturnsAsync(LogicResult<IList<PermissionGroup>>.BadRequest("Invalid user id"));
// Act
var result = await controller.GetUserGroups("invalid-user-id");
// Assert
var badRequestResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.BadRequest, badRequestResult.StatusCode);
Assert.Equal("Invalid user id", badRequestResult.Value);
}
[Fact]
public async Task GetUserGroups_ShouldReturnNotFound_WhenUserDoesNotExist() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.GetUserGroups(It.IsAny<string>()))
.ReturnsAsync(LogicResult<IList<PermissionGroup>>.NotFound("That user does not exist"));
// Act
var result = await controller.GetUserGroups("nonexistent-user-id");
// Assert
var notFoundResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.NotFound, notFoundResult.StatusCode);
Assert.Equal("That user does not exist", notFoundResult.Value);
}
[Fact]
public async Task GetGroup_ShouldReturnNotFound_WhenGroupDoesNotExist() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.GetGroup(It.IsAny<string>()))
.ReturnsAsync(LogicResult<PermissionGroup>.NotFound("That group does not exist"));
// Act
var result = await controller.GetGroup("nonexistent-group-name");
// Assert
var notFoundResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.NotFound, notFoundResult.StatusCode);
Assert.Equal("That group does not exist", notFoundResult.Value);
}
[Fact]
public async Task CreateGroup_ShouldReturnBadRequest_WhenGroupIsNull() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.CreateGroup(It.IsAny<PermissionGroup>()))
.ReturnsAsync(LogicResult<PermissionGroup>.BadRequest("Provide a group"));
// Act
var result = await controller.CreateGroup(null);
// Assert
var badRequestResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.BadRequest, badRequestResult.StatusCode);
Assert.Equal("Provide a group", badRequestResult.Value);
}
[Fact]
public async Task CreateGroup_ShouldReturnBadRequest_WhenGroupNameIsInvalid() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.CreateGroup(It.IsAny<PermissionGroup>()))
.ReturnsAsync(LogicResult<PermissionGroup>.BadRequest("Group names must start with 'group.'"));
// Act
var result = await controller.CreateGroup(new PermissionGroup { Name = "invalidgroupname" });
// Assert
var badRequestResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.BadRequest, badRequestResult.StatusCode);
Assert.Equal("Group names must start with 'group.'", badRequestResult.Value);
}
[Fact]
public async Task CreateGroup_ShouldReturnConflict_WhenGroupAlreadyExists() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.CreateGroup(It.IsAny<PermissionGroup>()))
.ReturnsAsync(LogicResult<PermissionGroup>.Conflict("That group already exists"));
// Act
var result = await controller.CreateGroup(new PermissionGroup { Name = "group.exists" });
// Assert
var conflictResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.Conflict, conflictResult.StatusCode);
Assert.Equal("That group already exists", conflictResult.Value);
}
[Fact]
public async Task UpdateGroup_ShouldReturnNotFound_WhenGroupDoesNotExist() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.UpdateGroup(It.IsAny<PermissionGroup>())).ReturnsAsync(LogicResult<PermissionGroup>.NotFound("That group does not exist"));
// Act
var result = await controller.UpdateGroup(new PermissionGroup { Name = "nonexistent-group-name" });
// Assert
var notFoundResult = Assert.IsType<ObjectResult>(result.Result);
Assert.Equal((int)HttpStatusCode.NotFound, notFoundResult.StatusCode);
Assert.Equal("That group does not exist", notFoundResult.Value);
}
[Fact]
public async Task DeleteGroup_ShouldReturnNotFound_WhenGroupDoesNotExist() {
// Arrange
var (mockGroups, mockPermissions, mockPerms, mockContext, controller) = SetupEnvironment();
mockGroups.Setup(g => g.DeleteGroup(It.IsAny<string>())).ReturnsAsync(LogicResult.NotFound("That group does not exist"));
// Act
var result = await controller.DeleteGroup("nonexistent-group-name");
// Assert
var notFoundResult = Assert.IsType<ObjectResult>(result);
Assert.Equal((int)HttpStatusCode.NotFound, notFoundResult.StatusCode);
Assert.Equal("That group does not exist", notFoundResult.Value);
}
}