Add users

PMDDesktop.Server.Users.Tests/PMDDesktop.Server.Users.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../PMDDesktop.Server.Users/PMDDesktop.Server.Users.csproj" />
+    <ProjectReference Include="../PMDDesktop/PMDDesktop.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

PMDDesktop.Server.Users.Tests/Roles/RoleReferenceTests.cs

@@ -0,0 +1,51 @@
+using PMDDesktop.Server.Users.Roles;
+using System.Text.Json;
+
+namespace PMDDesktop.Server.Users.Tests.Roles;
+
+public class RoleReferenceTests
+{
+
+	[Fact]
+	public async Task CanGetReference()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+		UserRole? role = await roleManager.TryCreateRole();
+		Assert.NotNull(role);
+
+		RoleReference reference = new(role);
+
+		Assert.True(reference.TryGetRole(manager, out UserRole? referRole));
+
+		Assert.Equal(role, referRole);
+
+	}
+
+	[Fact]
+	public async Task SerializationIsSimple()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+		UserRole? role = await roleManager.TryCreateRole();
+		Assert.NotNull(role);
+
+		RoleReference preReference = new(role);
+
+		JsonElement json = JsonSerializer.SerializeToElement(preReference, AppInfo.JSON_OPTIONS);
+
+		Assert.Equal(JsonValueKind.String, json.ValueKind);
+
+		RoleReference? postReference = JsonSerializer.Deserialize<RoleReference>(json);
+
+		Assert.NotNull(postReference);
+
+		Assert.True(postReference.TryGetRole(manager, out UserRole? referRole));
+
+		Assert.Equal(role, referRole);
+
+	}
+
+}

PMDDesktop.Server.Users.Tests/Roles/UserPermissionTests.cs

@@ -0,0 +1,18 @@
+using PMDDesktop.Server.Users.Roles;
+
+namespace PMDDesktop.Server.Users.Tests.Roles;
+
+public class UserPermissionTests
+{
+
+	[Theory]
+	[InlineData("manage-users")]
+	[InlineData("manage-roles")]
+	public void UserPermissionAllIncludesPermissions(string dataName)
+	{
+
+		Assert.Contains(UserPermission.ALL, permission => permission.DataName == dataName);
+
+	}
+
+}

PMDDesktop.Server.Users.Tests/Roles/UserRoleConverterTests.cs

@@ -0,0 +1,94 @@
+using PMDDesktop.Server.Users.Roles;
+using System.Text.Json;
+
+namespace PMDDesktop.Server.Users.Tests.Roles;
+
+public class UserRoleConverterTests
+{
+
+	[Fact]
+	public async Task RoleJsonContainsNullsForUnspecified()
+	{
+
+		UserRole role = new();
+
+		await role.SetPermission(UserPermission.MANAGE_USERS, true);
+
+		JsonDocument document = JsonSerializer.SerializeToDocument(role);
+
+		JsonElement manageRolesElement = document.RootElement.GetProperty(UserRoleConverter.PERMISSIONS_PROPERTY).GetProperty(UserPermission.MANAGE_ROLES.DataName);
+
+		Assert.Equal(JsonValueKind.Null, manageRolesElement.ValueKind);
+
+	}
+
+	[Fact]
+	public async Task RoleJsonContainsTrueWhenSpecified()
+	{
+
+		UserRole role = new();
+
+		await role.SetPermission(UserPermission.MANAGE_USERS, true);
+
+		JsonDocument document = JsonSerializer.SerializeToDocument(role);
+
+		JsonElement manageRolesElement = document.RootElement.GetProperty(UserRoleConverter.PERMISSIONS_PROPERTY).GetProperty(UserPermission.MANAGE_USERS.DataName);
+
+		Assert.Equal(JsonValueKind.True, manageRolesElement.ValueKind);
+
+	}
+
+	[Fact]
+	public async Task RoleJsonContainsFalseWhenSpecified()
+	{
+
+		UserRole role = new();
+
+		await role.SetPermission(UserPermission.MANAGE_USERS, false);
+
+		JsonDocument document = JsonSerializer.SerializeToDocument(role);
+
+		JsonElement manageRolesElement = document.RootElement.GetProperty(UserRoleConverter.PERMISSIONS_PROPERTY).GetProperty(UserPermission.MANAGE_USERS.DataName);
+
+		Assert.Equal(JsonValueKind.False, manageRolesElement.ValueKind);
+
+	}
+
+	[Fact]
+	public async Task RoleJsonWithSpecifiedPermissionThenUnspecifiedContainsNull()
+	{
+
+		UserRole role = new();
+
+		await role.SetPermission(UserPermission.MANAGE_USERS, true);
+		await role.SetPermission(UserPermission.MANAGE_USERS, null);
+
+		JsonDocument document = JsonSerializer.SerializeToDocument(role);
+
+		JsonElement manageRolesElement = document.RootElement.GetProperty(UserRoleConverter.PERMISSIONS_PROPERTY).GetProperty(UserPermission.MANAGE_USERS.DataName);
+
+		Assert.Equal(JsonValueKind.Null, manageRolesElement.ValueKind);
+
+	}
+
+	[Theory]
+	[InlineData(true)]
+	[InlineData(false)]
+	[InlineData(null)]
+	public async Task RoundTripRoleWithSpecifiedPermissionKeepsValue(bool? value)
+	{
+
+		UserRole role = new();
+
+		await role.SetPermission(UserPermission.MANAGE_USERS, value);
+
+		JsonDocument document = JsonSerializer.SerializeToDocument(role);
+
+		UserRole? newRole = JsonSerializer.Deserialize<UserRole>(document);
+		Assert.NotNull(newRole);
+
+		Assert.Equal(value, newRole.GetPermission(UserPermission.MANAGE_USERS));
+
+	}
+
+}

PMDDesktop.Server.Users.Tests/Roles/UserRoleManagerTests.cs

@@ -0,0 +1,194 @@
+using PMDDesktop.Server.Users.Roles;
+
+namespace PMDDesktop.Server.Users.Tests.Roles;
+
+public class UserRoleManagerTests
+{
+
+	[Fact]
+	public void UserRoleManagerPointsBackAtUserManager()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+
+		Assert.NotNull(roleManager);
+
+		Assert.Equal(manager, roleManager.Manager);
+
+		Assert.Equal(roleManager, roleManager.Manager.RoleManager);
+
+	}
+
+	[Fact]
+	public void UserRoleManagerHasDefaultRole()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+
+		Assert.NotNull(roleManager.DefaultRole);
+
+		Assert.True(roleManager.DefaultRole.IsDefaultRole);
+
+		Assert.Equal(Guid.Empty, roleManager.DefaultRole.GUID);
+
+		// Seeing if that's what we get for Guid.Empty
+
+		Assert.True(roleManager.TryGetRole(Guid.Empty, out UserRole? tryEmptyRole));
+		Assert.NotNull(tryEmptyRole);
+		Assert.Equal(roleManager.DefaultRole, tryEmptyRole);
+
+		// Test comparing to mock default role.
+
+		UserRole exampleDefault = UserRole.CreateDefaultRole();
+		UserRole managerDefault = roleManager.DefaultRole;
+
+		Assert.All(UserPermission.ALL, perm => Assert.Equal(exampleDefault.GetPermission(perm), managerDefault.GetPermission(perm)));
+
+	}
+
+	[Fact]
+	public async Task NewRolesAreOrderedLastBeforeDefault()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+
+		// Role 0
+		UserRole role0 = roleManager.DefaultRole;
+		Assert.Equal(role0, roleManager.Skip(0).First());
+		Assert.Single(roleManager);
+		Assert.Equal(role0, roleManager.SkipLast(0).Last());
+
+		// Role 1
+
+		UserRole? role1 = await roleManager.TryCreateRole();
+		Assert.Equal(role1, roleManager.Skip(0).First());
+		Assert.Equal(role0, roleManager.Skip(1).First());
+		Assert.Equal(2, roleManager.Count());
+		Assert.Equal(role1, roleManager.SkipLast(1).Last());
+		Assert.Equal(role0, roleManager.SkipLast(0).Last());
+
+		// Role 2
+
+		UserRole? role2 = await roleManager.TryCreateRole();
+		Assert.Equal(role1, roleManager.Skip(0).First());
+		Assert.Equal(role2, roleManager.Skip(1).First());
+		Assert.Equal(role0, roleManager.Skip(2).First());
+		Assert.Equal(3, roleManager.Count());
+		Assert.Equal(role1, roleManager.SkipLast(2).Last());
+		Assert.Equal(role2, roleManager.SkipLast(1).Last());
+		Assert.Equal(role0, roleManager.SkipLast(0).Last());
+
+		// Role 3
+
+		UserRole? role3 = await roleManager.TryCreateRole();
+		Assert.Equal(role1, roleManager.Skip(0).First());
+		Assert.Equal(role2, roleManager.Skip(1).First());
+		Assert.Equal(role3, roleManager.Skip(2).First());
+		Assert.Equal(role0, roleManager.Skip(3).First());
+		Assert.Equal(4, roleManager.Count());
+		Assert.Equal(role1, roleManager.SkipLast(3).Last());
+		Assert.Equal(role2, roleManager.SkipLast(2).Last());
+		Assert.Equal(role3, roleManager.SkipLast(1).Last());
+		Assert.Equal(role0, roleManager.SkipLast(0).Last());
+
+		// Role 4
+
+		UserRole? role4 = await roleManager.TryCreateRole();
+		Assert.Equal(role1, roleManager.Skip(0).First());
+		Assert.Equal(role2, roleManager.Skip(1).First());
+		Assert.Equal(role3, roleManager.Skip(2).First());
+		Assert.Equal(role4, roleManager.Skip(3).First());
+		Assert.Equal(role0, roleManager.Skip(4).First());
+		Assert.Equal(5, roleManager.Count());
+		Assert.Equal(role1, roleManager.SkipLast(4).Last());
+		Assert.Equal(role2, roleManager.SkipLast(3).Last());
+		Assert.Equal(role3, roleManager.SkipLast(2).Last());
+		Assert.Equal(role4, roleManager.SkipLast(1).Last());
+		Assert.Equal(role0, roleManager.SkipLast(0).Last());
+
+	}
+
+	[Fact]
+	public async Task SortingAffectsEnumeration()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+
+		UserRole defaultRole = roleManager.DefaultRole;
+		UserRole? role1 = await roleManager.TryCreateRole();
+		UserRole? role2 = await roleManager.TryCreateRole();
+		UserRole? role3 = await roleManager.TryCreateRole();
+		UserRole? role4 = await roleManager.TryCreateRole();
+
+		Assert.NotNull(role1);
+		Assert.NotNull(role2);
+		Assert.NotNull(role3);
+		Assert.NotNull(role4);
+
+		UserRole[] array1 = [.. roleManager];
+
+		Assert.Equal(role1, array1[0]);
+		Assert.Equal(role2, array1[1]);
+		Assert.Equal(role3, array1[2]);
+		Assert.Equal(role4, array1[3]);
+		Assert.Equal(defaultRole, array1[4]);
+
+		UserRole[] newSort2 = [role3, role2, role1, role4];
+
+		await roleManager.SetOrder(newSort2.Select(role => role.GUID));
+
+		UserRole[] array2 = [.. roleManager];
+
+		Assert.Equal(newSort2[0], array2[0]);
+		Assert.Equal(newSort2[1], array2[1]);
+		Assert.Equal(newSort2[2], array2[2]);
+		Assert.Equal(newSort2[3], array2[3]);
+		Assert.Equal(defaultRole, array2[4]);
+
+	}
+
+	[Fact]
+	public async Task SortingAffectsEnumerationWithDefaultSpecified()
+	{
+
+		UserManager manager = new();
+		UserRoleManager roleManager = manager.RoleManager;
+
+		UserRole defaultRole = roleManager.DefaultRole;
+		UserRole? role1 = await roleManager.TryCreateRole();
+		UserRole? role2 = await roleManager.TryCreateRole();
+		UserRole? role3 = await roleManager.TryCreateRole();
+		UserRole? role4 = await roleManager.TryCreateRole();
+
+		Assert.NotNull(role1);
+		Assert.NotNull(role2);
+		Assert.NotNull(role3);
+		Assert.NotNull(role4);
+
+		UserRole[] array1 = [.. roleManager];
+
+		Assert.Equal(role1, array1[0]);
+		Assert.Equal(role2, array1[1]);
+		Assert.Equal(role3, array1[2]);
+		Assert.Equal(role4, array1[3]);
+		Assert.Equal(defaultRole, array1[4]);
+
+		UserRole[] newSort2 = [role3, role2, role1, role4, defaultRole];
+
+		await roleManager.SetOrder(newSort2.Select(role => role.GUID));
+
+		UserRole[] array2 = [.. roleManager];
+
+		Assert.Equal(newSort2[0], array2[0]);
+		Assert.Equal(newSort2[1], array2[1]);
+		Assert.Equal(newSort2[2], array2[2]);
+		Assert.Equal(newSort2[3], array2[3]);
+		Assert.Equal(newSort2[4], array2[4]);
+
+	}
+
+}