DP 486 - Editing person / person invite roles

Frontend/CO.CDP.OrganisationApp.Tests/Pages/Users/AddUserTests.cs

@@ -2,6 +2,7 @@
 using Microsoft.AspNetCore.Mvc;
 using CO.CDP.OrganisationApp.Pages.Users;
 using Microsoft.AspNetCore.Mvc.RazorPages;
+using CO.CDP.OrganisationApp.Constants;
 
 namespace CO.CDP.OrganisationApp.Tests.Pages.Users;
 
@@ -24,7 +25,7 @@ public void OnGet_ShouldInitializeModel_WhenPersonInviteStateExists()
             FirstName = "John",
             LastName = "Johnson",
             Email = "john@johnson.com",
-            Scopes = new List<string> { AddUserModel.ScopeAdmin, AddUserModel.ScopeEditor }
+            Scopes = new List<string> { PersonScopes.Admin, PersonScopes.Editor }
         };
 
         _mockSession
@@ -37,7 +38,7 @@ public void OnGet_ShouldInitializeModel_WhenPersonInviteStateExists()
         Assert.Equal("Johnson", _addUserModel.LastName);
         Assert.Equal("john@johnson.com", _addUserModel.Email);
         Assert.True(_addUserModel.IsAdmin);
-        Assert.Equal(AddUserModel.ScopeEditor, _addUserModel.Role);
+        Assert.Equal(PersonScopes.Editor, _addUserModel.Role);
         Assert.IsType<PageResult>(result);
     }
 
@@ -73,7 +74,7 @@ public void OnPost_ShouldUpdateSessionAndRedirect_WhenModelStateIsValid()
         _addUserModel.LastName = "Johnson";
         _addUserModel.Email = "john@johnson.com";
         _addUserModel.IsAdmin = true;
-        _addUserModel.Role = AddUserModel.ScopeEditor;
+        _addUserModel.Role = PersonScopes.Editor;
 
         var initialState = new PersonInviteState();
         _mockSession.Setup(s => s.Get<PersonInviteState>(PersonInviteState.TempDataKey)).Returns(initialState);
@@ -85,8 +86,8 @@ public void OnPost_ShouldUpdateSessionAndRedirect_WhenModelStateIsValid()
             state.FirstName == "John" &&
             state.LastName == "Johnson" &&
             state.Email == "john@johnson.com" &&
-            state.Scopes.Contains(AddUserModel.ScopeAdmin) &&
-            state.Scopes.Contains(AddUserModel.ScopeEditor)
+            state.Scopes.Contains(PersonScopes.Admin) &&
+            state.Scopes.Contains(PersonScopes.Editor)
         )), Times.Once);
 
         var redirectResult = Assert.IsType<RedirectToPageResult>(result);
@@ -114,18 +115,18 @@ public void UpdateFields_ShouldUpdateAllFields_WhenFieldsAreNotEmpty()
     public void UpdateScopes_ShouldUpdateScopes_WhenIsAdminAndRoleIsEditor()
     {
         _addUserModel.IsAdmin = true;
-        _addUserModel.Role = AddUserModel.ScopeEditor;
+        _addUserModel.Role = PersonScopes.Editor;
 
         var initialState = new PersonInviteState
         {
-            Scopes = new List<string> { AddUserModel.ScopeViewer }
+            Scopes = new List<string> { PersonScopes.Viewer }
         };
 
         var updatedState = _addUserModel.UpdateScopes(initialState);
 
-        Assert.Contains(AddUserModel.ScopeAdmin, updatedState.Scopes ?? []);
-        Assert.Contains(AddUserModel.ScopeEditor, updatedState.Scopes ?? []);
-        Assert.DoesNotContain(AddUserModel.ScopeViewer, updatedState.Scopes ?? []);
+        Assert.Contains(PersonScopes.Admin, updatedState.Scopes ?? []);
+        Assert.Contains(PersonScopes.Editor, updatedState.Scopes ?? []);
+        Assert.DoesNotContain(PersonScopes.Viewer, updatedState.Scopes ?? []);
     }
 
     [Fact]
@@ -136,7 +137,7 @@ public void InitModel_ShouldSetModelPropertiesFromState_WhenStateHasData()
             FirstName = "John",
             LastName = "Johnson",
             Email = "john@johnson.com",
-            Scopes = new List<string> { AddUserModel.ScopeAdmin, AddUserModel.ScopeEditor }
+            Scopes = new List<string> { PersonScopes.Admin, PersonScopes.Editor }
         };
 
         _addUserModel.InitModel(state);
@@ -145,6 +146,6 @@ public void InitModel_ShouldSetModelPropertiesFromState_WhenStateHasData()
         Assert.Equal("Johnson", _addUserModel.LastName);
         Assert.Equal("john@johnson.com", _addUserModel.Email);
         Assert.True(_addUserModel.IsAdmin);
-        Assert.Equal(AddUserModel.ScopeEditor, _addUserModel.Role);
+        Assert.Equal(PersonScopes.Editor, _addUserModel.Role);
     }
 }

Frontend/CO.CDP.OrganisationApp.Tests/Pages/Users/ChangePersonInviteUserRoleTests.cs

@@ -0,0 +1,137 @@
+using Moq;
+using CO.CDP.OrganisationApp.Pages.Users;
+using CO.CDP.Organisation.WebApiClient;
+using CO.CDP.OrganisationApp.Constants;
+using CO.CDP.OrganisationApp.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace CO.CDP.OrganisationApp.Tests.Pages.Users;
+
+public class ChangePersonInviteUserRoleTests
+{
+    private readonly Mock<ISession> _mockSession;
+    private readonly Mock<IOrganisationClient> _mockOrganisationClient;
+    private readonly ChangeUserRoleModel _changeUserRoleModel;
+
+    public ChangePersonInviteUserRoleTests()
+    {
+        _mockSession = new Mock<ISession>();
+        _mockSession.Setup(s => s.Get<UserDetails>(Session.UserDetailsKey))
+            .Returns(new UserDetails() { UserUrn = "whatever" });
+
+        _mockOrganisationClient = new Mock<IOrganisationClient>();
+        _changeUserRoleModel = new ChangeUserRoleModel(_mockOrganisationClient.Object, _mockSession.Object);
+    }
+
+    [Fact]
+    public async Task OnGet_ShouldInitializeModel_WhenPersonInviteExists()
+    {
+        var mockPersonInvite = new PersonInviteModel(
+                                    "a@b.com",
+                                    "John",
+                                    new Guid(),
+                                    "Smith",
+                                    new List<string> { PersonScopes.Admin, PersonScopes.Editor }
+                                );
+
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonInvitesAsync(mockPersonInvite.Id))
+            .ReturnsAsync(new List<PersonInviteModel>() { mockPersonInvite });
+
+        var result = await _changeUserRoleModel.OnGetPersonInvite();
+
+        Assert.Equal("John Smith", _changeUserRoleModel.UserFullName);
+        Assert.True(_changeUserRoleModel.IsAdmin);
+        Assert.Equal(PersonScopes.Editor, _changeUserRoleModel.Role);
+    }
+
+    [Fact]
+    public async Task OnGet_RedirectsToNotFound_WhenPersonInviteDoesntExist()
+    {
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonInvitesAsync(It.IsAny<Guid>()))
+            .ThrowsAsync(new CO.CDP.Organisation.WebApiClient.ApiException("message", 404, "response", null, null));
+
+        var result = await _changeUserRoleModel.OnGetPersonInvite();
+
+        var redirectResult = Assert.IsType<RedirectResult>(result);
+
+        Assert.Equal("/page-not-found", redirectResult.Url);
+    }
+
+    [Fact]
+    public async Task OnPostPersonInvite_ShouldReturnPageResult_WhenModelStateIsInvalid()
+    {
+        var mockPersonInvite = new PersonInviteModel(
+                                    "a@b.com",
+                                    "John",
+                                    new Guid(),
+                                    "Smith",
+                                    new List<string> { PersonScopes.Admin, PersonScopes.Editor }
+                                );
+
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonInvitesAsync(mockPersonInvite.Id))
+            .ReturnsAsync(new List<PersonInviteModel>() { mockPersonInvite });
+
+        _changeUserRoleModel.IsAdmin = true;
+        _changeUserRoleModel.Role = null;
+
+        _changeUserRoleModel.ModelState.AddModelError("Role", "Required");       
+
+        var result = await _changeUserRoleModel.OnPostPersonInvite();
+        Assert.IsType<PageResult>(result);
+    }
+
+    [Fact]
+    public async Task OnPostPersonInvite_RedirectsToNotFound_WhenPersonInviteDoesntExist()
+    {
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonInvitesAsync(It.IsAny<Guid>()))
+            .ThrowsAsync(new CO.CDP.Organisation.WebApiClient.ApiException("message", 404, "response", null, null));
+
+        var result = await _changeUserRoleModel.OnPostPersonInvite();
+
+        var redirectResult = Assert.IsType<RedirectResult>(result);
+
+        Assert.Equal("/page-not-found", redirectResult.Url);
+    }
+
+    [Fact]
+    public async Task OnPostPersonInvite_ShouldUpdatePersonInviteTableAndRedirect_WhenModelStateIsValid()
+    {
+        var mockPersonInvite = new PersonInviteModel(
+                                    "a@b.com",
+                                    "John",
+                                    new Guid(),
+                                    "Smith",
+                                    new List<string> { PersonScopes.Admin, PersonScopes.Editor }
+                                );
+
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonInvitesAsync(mockPersonInvite.Id))
+            .ReturnsAsync(new List<PersonInviteModel>() { mockPersonInvite });
+
+        _changeUserRoleModel.IsAdmin = true;
+        _changeUserRoleModel.Role = PersonScopes.Viewer;
+
+        var result = await _changeUserRoleModel.OnPostPersonInvite();
+
+        var redirectResult = Assert.IsType<RedirectToPageResult>(result);
+        Assert.Equal("UserSummary", redirectResult.PageName);
+
+        _mockOrganisationClient.Verify(s => s.UpdatePersonInviteAsync(
+                                                It.IsAny<Guid>(),
+                                                It.IsAny<Guid>(),
+                                                It.Is<UpdateInvitedPersonToOrganisation>(u =>
+                                                    u.Scopes.Contains(PersonScopes.Viewer) &&
+                                                    u.Scopes.Contains(PersonScopes.Admin) &&
+                                                    u.Scopes.Count == 2
+                                                )
+                                            ),
+                                            Times.Once
+                                        );
+    }
+}

Frontend/CO.CDP.OrganisationApp.Tests/Pages/Users/ChangePersonUserRoleTests.cs

@@ -0,0 +1,137 @@
+using Moq;
+using CO.CDP.OrganisationApp.Pages.Users;
+using CO.CDP.Organisation.WebApiClient;
+using CO.CDP.OrganisationApp.Constants;
+using CO.CDP.OrganisationApp.Models;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace CO.CDP.OrganisationApp.Tests.Pages.Users;
+
+public class ChangePersonUserRoleTests
+{
+    private readonly Mock<ISession> _mockSession;
+    private readonly Mock<IOrganisationClient> _mockOrganisationClient;
+    private readonly ChangeUserRoleModel _changeUserRoleModel;
+
+    public ChangePersonUserRoleTests()
+    {
+        _mockSession = new Mock<ISession>();
+        _mockSession.Setup(s => s.Get<UserDetails>(Session.UserDetailsKey))
+            .Returns(new UserDetails() { UserUrn = "whatever" });
+
+        _mockOrganisationClient = new Mock<IOrganisationClient>();
+        _changeUserRoleModel = new ChangeUserRoleModel(_mockOrganisationClient.Object, _mockSession.Object);
+    }
+
+    [Fact]
+    public async Task OnGet_ShouldInitializeModel_WhenPersonExists()
+    {
+        var mockPerson = new Organisation.WebApiClient.Person(
+                                    "a@b.com",
+                                    "John",
+                                    new Guid(),
+                                    "Smith",
+                                    new List<string> { PersonScopes.Admin, PersonScopes.Editor }
+                                );
+
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonsAsync(mockPerson.Id))
+            .ReturnsAsync(new List<Organisation.WebApiClient.Person>() { mockPerson });
+
+        var result = await _changeUserRoleModel.OnGetPerson();
+
+        Assert.Equal("John Smith", _changeUserRoleModel.UserFullName);
+        Assert.True(_changeUserRoleModel.IsAdmin);
+        Assert.Equal(PersonScopes.Editor, _changeUserRoleModel.Role);
+    }
+
+    [Fact]
+    public async Task OnGet_RedirectsToNotFound_WhenPersonDoesntExist()
+    {
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonsAsync(It.IsAny<Guid>()))
+            .ThrowsAsync(new CO.CDP.Organisation.WebApiClient.ApiException("message", 404, "response", null, null));
+
+        var result = await _changeUserRoleModel.OnGetPerson();
+
+        var redirectResult = Assert.IsType<RedirectResult>(result);
+
+        Assert.Equal("/page-not-found", redirectResult.Url);
+    }
+
+    [Fact]
+    public async Task OnPostPerson_ShouldReturnPageResult_WhenModelStateIsInvalid()
+    {
+        var mockPerson = new Organisation.WebApiClient.Person(
+                                    "a@b.com",
+                                    "John",
+                                    new Guid(),
+                                    "Smith",
+                                    new List<string> { PersonScopes.Admin, PersonScopes.Editor }
+                                );
+
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonsAsync(mockPerson.Id))
+            .ReturnsAsync(new List<Organisation.WebApiClient.Person>() { mockPerson });
+
+        _changeUserRoleModel.IsAdmin = true;
+        _changeUserRoleModel.Role = null;
+
+        _changeUserRoleModel.ModelState.AddModelError("Role", "Required");
+
+        var result = await _changeUserRoleModel.OnPostPerson();
+        Assert.IsType<PageResult>(result);
+    }
+
+    [Fact]
+    public async Task OnPostPerson_RedirectsToNotFound_WhenPersonInviteDoesntExist()
+    {
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonsAsync(It.IsAny<Guid>()))
+            .ThrowsAsync(new CO.CDP.Organisation.WebApiClient.ApiException("message", 404, "response", null, null));
+
+        var result = await _changeUserRoleModel.OnPostPerson();
+
+        var redirectResult = Assert.IsType<RedirectResult>(result);
+
+        Assert.Equal("/page-not-found", redirectResult.Url);
+    }
+
+    [Fact]
+    public async Task OnPostPerson_ShouldUpdatePersonTableAndRedirect_WhenModelStateIsValid()
+    {
+        var mockPerson = new Organisation.WebApiClient.Person(
+                                    "a@b.com",
+                                    "John",
+                                    new Guid(),
+                                    "Smith",
+                                    new List<string> { PersonScopes.Admin, PersonScopes.Editor }
+                                );
+
+        _mockOrganisationClient
+            .Setup(s => s.GetOrganisationPersonsAsync(mockPerson.Id))
+            .ReturnsAsync(new List<Organisation.WebApiClient.Person>() { mockPerson });
+
+        _changeUserRoleModel.IsAdmin = true;
+        _changeUserRoleModel.Role = PersonScopes.Viewer;
+
+        var result = await _changeUserRoleModel.OnPostPerson();
+
+        var redirectResult = Assert.IsType<RedirectToPageResult>(result);
+        Assert.Equal("UserSummary", redirectResult.PageName);
+
+        _mockOrganisationClient.Verify(s => s.UpdateOrganisationPersonAsync(
+                                                It.IsAny<Guid>(),
+                                                It.IsAny<Guid>(),
+                                                It.Is<UpdatePersonToOrganisation>(u =>
+                                                    u.Scopes.Contains(PersonScopes.Viewer) &&
+                                                    u.Scopes.Contains(PersonScopes.Admin) &&
+                                                    u.Scopes.Count == 2
+                                                )
+                                            ),
+                                            Times.Once
+                                        );
+    }
+}