[PM-10325] Rename OrganizationUser Delete and BulkDelete endpoints to Remove and BulkRemove (#4711)

* Rename IDeleteOrganizationUserCommand to IRemoveOrganizationUserCommand

* Rename IOrganizationService DeleteUser methods to RemoveUser

* Rename API endpoints for deleting organization users to "Remove"

* chore: Rename Delete method to Remove in MembersController

bitwarden_license/src/Scim/Controllers/v2/UsersController.cs

@@ -21,7 +21,7 @@ public class UsersController : Controller
     private readonly IOrganizationUserRepository _organizationUserRepository;
     private readonly IOrganizationService _organizationService;
     private readonly IGetUsersListQuery _getUsersListQuery;
-    private readonly IDeleteOrganizationUserCommand _deleteOrganizationUserCommand;
+    private readonly IRemoveOrganizationUserCommand _removeOrganizationUserCommand;
     private readonly IPatchUserCommand _patchUserCommand;
     private readonly IPostUserCommand _postUserCommand;
     private readonly ILogger<UsersController> _logger;
@@ -31,7 +31,7 @@ public class UsersController : Controller
         IOrganizationUserRepository organizationUserRepository,
         IOrganizationService organizationService,
         IGetUsersListQuery getUsersListQuery,
-        IDeleteOrganizationUserCommand deleteOrganizationUserCommand,
+        IRemoveOrganizationUserCommand removeOrganizationUserCommand,
         IPatchUserCommand patchUserCommand,
         IPostUserCommand postUserCommand,
         ILogger<UsersController> logger)
@@ -40,7 +40,7 @@ public class UsersController : Controller
         _organizationUserRepository = organizationUserRepository;
         _organizationService = organizationService;
         _getUsersListQuery = getUsersListQuery;
-        _deleteOrganizationUserCommand = deleteOrganizationUserCommand;
+        _removeOrganizationUserCommand = removeOrganizationUserCommand;
         _patchUserCommand = patchUserCommand;
         _postUserCommand = postUserCommand;
         _logger = logger;
@@ -120,7 +120,7 @@ public class UsersController : Controller
     [HttpDelete("{id}")]
     public async Task<IActionResult> Delete(Guid organizationId, Guid id)
     {
-        await _deleteOrganizationUserCommand.DeleteUserAsync(organizationId, id, EventSystemUser.SCIM);
+        await _removeOrganizationUserCommand.RemoveUserAsync(organizationId, id, EventSystemUser.SCIM);
         return new NoContentResult();
     }
 }

src/Api/AdminConsole/Controllers/OrganizationUsersController.cs

@@ -506,8 +506,8 @@ public class OrganizationUsersController : Controller
     }
 
     [HttpDelete("{id}")]
-    [HttpPost("{id}/delete")]
+    [HttpPost("{id}/remove")]
-    public async Task Delete(string orgId, string id)
+    public async Task Remove(string orgId, string id)
     {
         var orgGuidId = new Guid(orgId);
         if (!await _currentContext.ManageUsers(orgGuidId))
@@ -516,12 +516,12 @@ public class OrganizationUsersController : Controller
         }
 
         var userId = _userService.GetProperUserId(User);
-        await _organizationService.DeleteUserAsync(orgGuidId, new Guid(id), userId.Value);
+        await _organizationService.RemoveUserAsync(orgGuidId, new Guid(id), userId.Value);
     }
 
     [HttpDelete("")]
-    [HttpPost("delete")]
+    [HttpPost("remove")]
-    public async Task<ListResponseModel<OrganizationUserBulkResponseModel>> BulkDelete(string orgId, [FromBody] OrganizationUserBulkRequestModel model)
+    public async Task<ListResponseModel<OrganizationUserBulkResponseModel>> BulkRemove(string orgId, [FromBody] OrganizationUserBulkRequestModel model)
     {
         var orgGuidId = new Guid(orgId);
         if (!await _currentContext.ManageUsers(orgGuidId))
@@ -530,7 +530,7 @@ public class OrganizationUsersController : Controller
         }
 
         var userId = _userService.GetProperUserId(User);
-        var result = await _organizationService.DeleteUsersAsync(orgGuidId, model.Ids, userId.Value);
+        var result = await _organizationService.RemoveUsersAsync(orgGuidId, model.Ids, userId.Value);
         return new ListResponseModel<OrganizationUserBulkResponseModel>(result.Select(r =>
             new OrganizationUserBulkResponseModel(r.Item1.Id, r.Item2)));
     }

src/Api/AdminConsole/Controllers/OrganizationsController.cs

@@ -231,7 +231,7 @@ public class OrganizationsController : Controller
         }
 
 
-        await _organizationService.DeleteUserAsync(orgGuidId, user.Id);
+        await _organizationService.RemoveUserAsync(orgGuidId, user.Id);
     }
 
     [HttpDelete("{id}")]

src/Api/AdminConsole/Public/Controllers/MembersController.cs

@@ -226,24 +226,24 @@ public class MembersController : Controller
     }
 
     /// <summary>
-    /// Delete a member.
+    /// Remove a member.
     /// </summary>
     /// <remarks>
-    /// Permanently deletes a member from the organization. This cannot be undone.
+    /// Permanently removes a member from the organization. This cannot be undone.
     /// The user account will still remain. The user is only removed from the organization.
     /// </remarks>
-    /// <param name="id">The identifier of the member to be deleted.</param>
+    /// <param name="id">The identifier of the member to be removed.</param>
     [HttpDelete("{id}")]
     [ProducesResponseType((int)HttpStatusCode.OK)]
     [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Delete(Guid id)
+    public async Task<IActionResult> Remove(Guid id)
     {
         var user = await _organizationUserRepository.GetByIdAsync(id);
         if (user == null || user.OrganizationId != _currentContext.OrganizationId)
         {
             return new NotFoundResult();
         }
-        await _organizationService.DeleteUserAsync(_currentContext.OrganizationId.Value, id, null);
+        await _organizationService.RemoveUserAsync(_currentContext.OrganizationId.Value, id, null);
         return new OkResult();
     }
 

src/Core/AdminConsole/OrganizationFeatures/OrganizationUsers/Interfaces/IRemoveOrganizationUserCommand.cs

@@ -2,9 +2,9 @@
 
 namespace Bit.Core.AdminConsole.OrganizationFeatures.OrganizationUsers.Interfaces;
 
-public interface IDeleteOrganizationUserCommand
+public interface IRemoveOrganizationUserCommand
 {
-    Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId);
+    Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId);
 
-    Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, EventSystemUser eventSystemUser);
+    Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, EventSystemUser eventSystemUser);
 }

src/Core/AdminConsole/OrganizationFeatures/OrganizationUsers/RemoveOrganizationUserCommand.cs

@@ -6,12 +6,12 @@ using Bit.Core.Services;
 
 namespace Bit.Core.AdminConsole.OrganizationFeatures.OrganizationUsers;
 
-public class DeleteOrganizationUserCommand : IDeleteOrganizationUserCommand
+public class RemoveOrganizationUserCommand : IRemoveOrganizationUserCommand
 {
     private readonly IOrganizationUserRepository _organizationUserRepository;
     private readonly IOrganizationService _organizationService;
 
-    public DeleteOrganizationUserCommand(
+    public RemoveOrganizationUserCommand(
         IOrganizationUserRepository organizationUserRepository,
         IOrganizationService organizationService
     )
@@ -20,18 +20,18 @@ public class DeleteOrganizationUserCommand : IDeleteOrganizationUserCommand
         _organizationService = organizationService;
     }
 
-    public async Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId)
+    public async Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId)
     {
         await ValidateDeleteUserAsync(organizationId, organizationUserId);
 
-        await _organizationService.DeleteUserAsync(organizationId, organizationUserId, deletingUserId);
+        await _organizationService.RemoveUserAsync(organizationId, organizationUserId, deletingUserId);
     }
 
-    public async Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, EventSystemUser eventSystemUser)
+    public async Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, EventSystemUser eventSystemUser)
     {
         await ValidateDeleteUserAsync(organizationId, organizationUserId);
 
-        await _organizationService.DeleteUserAsync(organizationId, organizationUserId, eventSystemUser);
+        await _organizationService.RemoveUserAsync(organizationId, organizationUserId, eventSystemUser);
     }
 
     private async Task ValidateDeleteUserAsync(Guid organizationId, Guid organizationUserId)

src/Core/AdminConsole/Services/IOrganizationService.cs

@@ -55,12 +55,12 @@ public interface IOrganizationService
         Guid confirmingUserId, IUserService userService);
     Task<List<Tuple<OrganizationUser, string>>> ConfirmUsersAsync_vNext(Guid organizationId, Dictionary<Guid, string> keys,
         Guid confirmingUserId);
-    [Obsolete("IDeleteOrganizationUserCommand should be used instead. To be removed by EC-607.")]
+    [Obsolete("IRemoveOrganizationUserCommand should be used instead. To be removed by EC-607.")]
-    Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId);
+    Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId);
-    [Obsolete("IDeleteOrganizationUserCommand should be used instead. To be removed by EC-607.")]
+    [Obsolete("IRemoveOrganizationUserCommand should be used instead. To be removed by EC-607.")]
-    Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, EventSystemUser systemUser);
+    Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, EventSystemUser systemUser);
-    Task DeleteUserAsync(Guid organizationId, Guid userId);
+    Task RemoveUserAsync(Guid organizationId, Guid userId);
-    Task<List<Tuple<OrganizationUser, string>>> DeleteUsersAsync(Guid organizationId,
+    Task<List<Tuple<OrganizationUser, string>>> RemoveUsersAsync(Guid organizationId,
         IEnumerable<Guid> organizationUserIds, Guid? deletingUserId);
     Task UpdateUserResetPasswordEnrollmentAsync(Guid organizationId, Guid userId, string resetPasswordKey, Guid? callingUserId);
     Task ImportAsync(Guid organizationId, IEnumerable<ImportedGroup> groups,

src/Core/AdminConsole/Services/Implementations/OrganizationService.cs

@@ -1591,15 +1591,15 @@ public class OrganizationService : IOrganizationService
         }
     }
 
-    [Obsolete("IDeleteOrganizationUserCommand should be used instead. To be removed by EC-607.")]
+    [Obsolete("IRemoveOrganizationUserCommand should be used instead. To be removed by EC-607.")]
-    public async Task DeleteUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId)
+    public async Task RemoveUserAsync(Guid organizationId, Guid organizationUserId, Guid? deletingUserId)
     {
         var orgUser = await RepositoryDeleteUserAsync(organizationId, organizationUserId, deletingUserId);
         await _eventService.LogOrganizationUserEventAsync(orgUser, EventType.OrganizationUser_Removed);
     }
 
-    [Obsolete("IDeleteOrganizationUserCommand should be used instead. To be removed by EC-607.")]
+    [Obsolete("IRemoveOrganizationUserCommand should be used instead. To be removed by EC-607.")]
-    public async Task DeleteUserAsync(Guid organizationId, Guid organizationUserId,
+    public async Task RemoveUserAsync(Guid organizationId, Guid organizationUserId,
         EventSystemUser systemUser)
     {
         var orgUser = await RepositoryDeleteUserAsync(organizationId, organizationUserId, null);
@@ -1640,7 +1640,7 @@ public class OrganizationService : IOrganizationService
         return orgUser;
     }
 
-    public async Task DeleteUserAsync(Guid organizationId, Guid userId)
+    public async Task RemoveUserAsync(Guid organizationId, Guid userId)
     {
         var orgUser = await _organizationUserRepository.GetByOrganizationAsync(organizationId, userId);
         if (orgUser == null)
@@ -1662,7 +1662,7 @@ public class OrganizationService : IOrganizationService
         }
     }
 
-    public async Task<List<Tuple<OrganizationUser, string>>> DeleteUsersAsync(Guid organizationId,
+    public async Task<List<Tuple<OrganizationUser, string>>> RemoveUsersAsync(Guid organizationId,
         IEnumerable<Guid> organizationUsersId,
         Guid? deletingUserId)
     {

src/Core/AdminConsole/Services/Implementations/PolicyService.cs

@@ -293,7 +293,7 @@ public class PolicyService : IPolicyService
                                     "Policy could not be enabled. Non-compliant members will lose access to their accounts. Identify members without two-step login from the policies column in the members page.");
                             }
 
-                            await organizationService.DeleteUserAsync(policy.OrganizationId, orgUser.Id,
+                            await organizationService.RemoveUserAsync(policy.OrganizationId, orgUser.Id,
                                 savingUserId);
                             await _mailService.SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(
                                 org.DisplayName(), orgUser.Email);
@@ -309,7 +309,7 @@ public class PolicyService : IPolicyService
                                     && ou.OrganizationId != org.Id
                                     && ou.Status != OrganizationUserStatusType.Invited))
                         {
-                            await organizationService.DeleteUserAsync(policy.OrganizationId, orgUser.Id,
+                            await organizationService.RemoveUserAsync(policy.OrganizationId, orgUser.Id,
                                 savingUserId);
                             await _mailService.SendOrganizationUserRemovedForPolicySingleOrgEmailAsync(
                                 org.DisplayName(), orgUser.Email);
@@ -350,7 +350,7 @@ public class PolicyService : IPolicyService
                                     "Policy could not be enabled. Non-compliant members will lose access to their accounts. Identify members without two-step login from the policies column in the members page.");
                             }
 
-                            await organizationService.DeleteUserAsync(policy.OrganizationId, orgUser.Id,
+                            await organizationService.RemoveUserAsync(policy.OrganizationId, orgUser.Id,
                                 savingUserId);
                             await _mailService.SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(
                                 org.DisplayName(), orgUser.Email);
@@ -366,7 +366,7 @@ public class PolicyService : IPolicyService
                                     && ou.OrganizationId != org.Id
                                     && ou.Status != OrganizationUserStatusType.Invited))
                         {
-                            await organizationService.DeleteUserAsync(policy.OrganizationId, orgUser.Id,
+                            await organizationService.RemoveUserAsync(policy.OrganizationId, orgUser.Id,
                                 savingUserId);
                             await _mailService.SendOrganizationUserRemovedForPolicySingleOrgEmailAsync(
                                 org.DisplayName(), orgUser.Email);

src/Core/Auth/Services/Implementations/EmergencyAccessService.cs

@@ -341,7 +341,7 @@ public class EmergencyAccessService : IEmergencyAccessService
         {
             if (o.Type != OrganizationUserType.Owner)
             {
-                await _organizationService.DeleteUserAsync(o.OrganizationId, grantor.Id);
+                await _organizationService.RemoveUserAsync(o.OrganizationId, grantor.Id);
             }
         }
     }

src/Core/OrganizationFeatures/OrganizationServiceCollectionExtensions.cs

@@ -86,7 +86,7 @@ public static class OrganizationServiceCollectionExtensions
 
     private static void AddOrganizationUserCommands(this IServiceCollection services)
     {
-        services.AddScoped<IDeleteOrganizationUserCommand, DeleteOrganizationUserCommand>();
+        services.AddScoped<IRemoveOrganizationUserCommand, RemoveOrganizationUserCommand>();
         services.AddScoped<IUpdateOrganizationUserCommand, UpdateOrganizationUserCommand>();
         services.AddScoped<IUpdateOrganizationUserGroupsCommand, UpdateOrganizationUserGroupsCommand>();
     }

src/Core/Services/Implementations/UserService.cs

@@ -1298,7 +1298,7 @@ public class UserService : UserManager<User>, IUserService, IDisposable
 
         var removeOrgUserTasks = twoFactorPolicies.Select(async p =>
         {
-            await organizationService.DeleteUserAsync(p.OrganizationId, user.Id);
+            await organizationService.RemoveUserAsync(p.OrganizationId, user.Id);
             var organization = await _organizationRepository.GetByIdAsync(p.OrganizationId);
             await _mailService.SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(
                 organization.DisplayName(), user.Email);

test/Api.Test/AdminConsole/Controllers/OrganizationsControllerTests.cs

@@ -126,7 +126,7 @@ public class OrganizationsControllerTests : IDisposable
         Assert.Contains("Your organization's Single Sign-On settings prevent you from leaving.",
             exception.Message);
 
-        await _organizationService.DidNotReceiveWithAnyArgs().DeleteUserAsync(default, default);
+        await _organizationService.DidNotReceiveWithAnyArgs().RemoveUserAsync(default, default);
     }
 
     [Theory]
@@ -155,8 +155,8 @@ public class OrganizationsControllerTests : IDisposable
         _ssoConfigRepository.GetByOrganizationIdAsync(orgId).Returns(ssoConfig);
         _userService.GetUserByPrincipalAsync(Arg.Any<ClaimsPrincipal>()).Returns(user);
 
-        await _organizationService.DeleteUserAsync(orgId, user.Id);
+        await _organizationService.RemoveUserAsync(orgId, user.Id);
-        await _organizationService.Received(1).DeleteUserAsync(orgId, user.Id);
+        await _organizationService.Received(1).RemoveUserAsync(orgId, user.Id);
     }
 
     [Theory, AutoData]

test/Api.Test/Billing/Controllers/OrganizationsControllerTests.cs

@@ -117,8 +117,8 @@ public class OrganizationsControllerTests : IDisposable
         _ssoConfigRepository.GetByOrganizationIdAsync(orgId).Returns(ssoConfig);
         _userService.GetUserByPrincipalAsync(Arg.Any<ClaimsPrincipal>()).Returns(user);
 
-        await _organizationService.DeleteUserAsync(orgId, user.Id);
+        await _organizationService.RemoveUserAsync(orgId, user.Id);
-        await _organizationService.Received(1).DeleteUserAsync(orgId, user.Id);
+        await _organizationService.Received(1).RemoveUserAsync(orgId, user.Id);
     }
 
     [Theory, AutoData]

test/Core.Test/AdminConsole/OrganizationFeatures/OrganizationUsers/RemoveOrganizationUserCommandTests.cs

@@ -12,11 +12,11 @@ using Xunit;
 namespace Bit.Core.Test.AdminConsole.OrganizationFeatures.OrganizationUsers;
 
 [SutProviderCustomize]
-public class DeleteOrganizationUserCommandTests
+public class RemoveOrganizationUserCommandTests
 {
     [Theory]
     [BitAutoData]
-    public async Task DeleteUser_Success(SutProvider<DeleteOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId)
+    public async Task RemoveUser_Success(SutProvider<RemoveOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId)
     {
         sutProvider.GetDependency<IOrganizationUserRepository>()
             .GetByIdAsync(organizationUserId)
@@ -26,21 +26,21 @@ public class DeleteOrganizationUserCommandTests
                 OrganizationId = organizationId
             });
 
-        await sutProvider.Sut.DeleteUserAsync(organizationId, organizationUserId, null);
+        await sutProvider.Sut.RemoveUserAsync(organizationId, organizationUserId, null);
 
-        await sutProvider.GetDependency<IOrganizationService>().Received(1).DeleteUserAsync(organizationId, organizationUserId, null);
+        await sutProvider.GetDependency<IOrganizationService>().Received(1).RemoveUserAsync(organizationId, organizationUserId, null);
     }
 
     [Theory]
     [BitAutoData]
-    public async Task DeleteUser_NotFound_Throws(SutProvider<DeleteOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId)
+    public async Task RemoveUser_NotFound_Throws(SutProvider<RemoveOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId)
     {
-        await Assert.ThrowsAsync<NotFoundException>(async () => await sutProvider.Sut.DeleteUserAsync(organizationId, organizationUserId, null));
+        await Assert.ThrowsAsync<NotFoundException>(async () => await sutProvider.Sut.RemoveUserAsync(organizationId, organizationUserId, null));
     }
 
     [Theory]
     [BitAutoData]
-    public async Task DeleteUser_MismatchingOrganizationId_Throws(SutProvider<DeleteOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId)
+    public async Task RemoveUser_MismatchingOrganizationId_Throws(SutProvider<RemoveOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId)
     {
         sutProvider.GetDependency<IOrganizationUserRepository>()
             .GetByIdAsync(organizationUserId)
@@ -50,12 +50,12 @@ public class DeleteOrganizationUserCommandTests
                 OrganizationId = Guid.NewGuid()
             });
 
-        await Assert.ThrowsAsync<NotFoundException>(async () => await sutProvider.Sut.DeleteUserAsync(organizationId, organizationUserId, null));
+        await Assert.ThrowsAsync<NotFoundException>(async () => await sutProvider.Sut.RemoveUserAsync(organizationId, organizationUserId, null));
     }
 
     [Theory]
     [BitAutoData]
-    public async Task DeleteUser_WithEventSystemUser_Success(SutProvider<DeleteOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId, EventSystemUser eventSystemUser)
+    public async Task RemoveUser_WithEventSystemUser_Success(SutProvider<RemoveOrganizationUserCommand> sutProvider, Guid organizationId, Guid organizationUserId, EventSystemUser eventSystemUser)
     {
         sutProvider.GetDependency<IOrganizationUserRepository>()
             .GetByIdAsync(organizationUserId)
@@ -65,8 +65,8 @@ public class DeleteOrganizationUserCommandTests
                 OrganizationId = organizationId
             });
 
-        await sutProvider.Sut.DeleteUserAsync(organizationId, organizationUserId, eventSystemUser);
+        await sutProvider.Sut.RemoveUserAsync(organizationId, organizationUserId, eventSystemUser);
 
-        await sutProvider.GetDependency<IOrganizationService>().Received(1).DeleteUserAsync(organizationId, organizationUserId, eventSystemUser);
+        await sutProvider.GetDependency<IOrganizationService>().Received(1).RemoveUserAsync(organizationId, organizationUserId, eventSystemUser);
     }
 }

test/Core.Test/AdminConsole/Services/OrganizationServiceTests.cs

@@ -1182,7 +1182,7 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUser_InvalidUser(OrganizationUser organizationUser, OrganizationUser deletingUser,
+    public async Task RemoveUser_InvalidUser(OrganizationUser organizationUser, OrganizationUser deletingUser,
         SutProvider<OrganizationService> sutProvider)
     {
         var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
@@ -1190,24 +1190,24 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
         organizationUserRepository.GetByIdAsync(organizationUser.Id).Returns(organizationUser);
 
         var exception = await Assert.ThrowsAsync<BadRequestException>(
-            () => sutProvider.Sut.DeleteUserAsync(Guid.NewGuid(), organizationUser.Id, deletingUser.UserId));
+            () => sutProvider.Sut.RemoveUserAsync(Guid.NewGuid(), organizationUser.Id, deletingUser.UserId));
         Assert.Contains("User not valid.", exception.Message);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUser_RemoveYourself(OrganizationUser deletingUser, SutProvider<OrganizationService> sutProvider)
+    public async Task RemoveUser_RemoveYourself(OrganizationUser deletingUser, SutProvider<OrganizationService> sutProvider)
     {
         var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
 
         organizationUserRepository.GetByIdAsync(deletingUser.Id).Returns(deletingUser);
 
         var exception = await Assert.ThrowsAsync<BadRequestException>(
-            () => sutProvider.Sut.DeleteUserAsync(deletingUser.OrganizationId, deletingUser.Id, deletingUser.UserId));
+            () => sutProvider.Sut.RemoveUserAsync(deletingUser.OrganizationId, deletingUser.Id, deletingUser.UserId));
         Assert.Contains("You cannot remove yourself.", exception.Message);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUser_NonOwnerRemoveOwner(
+    public async Task RemoveUser_NonOwnerRemoveOwner(
         [OrganizationUser(type: OrganizationUserType.Owner)] OrganizationUser organizationUser,
         [OrganizationUser(type: OrganizationUserType.Admin)] OrganizationUser deletingUser,
         SutProvider<OrganizationService> sutProvider)
@@ -1220,12 +1220,12 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
         currentContext.OrganizationAdmin(deletingUser.OrganizationId).Returns(true);
 
         var exception = await Assert.ThrowsAsync<BadRequestException>(
-            () => sutProvider.Sut.DeleteUserAsync(deletingUser.OrganizationId, organizationUser.Id, deletingUser.UserId));
+            () => sutProvider.Sut.RemoveUserAsync(deletingUser.OrganizationId, organizationUser.Id, deletingUser.UserId));
         Assert.Contains("Only owners can delete other owners.", exception.Message);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUser_LastOwner(
+    public async Task RemoveUser_LastOwner(
         [OrganizationUser(type: OrganizationUserType.Owner)] OrganizationUser organizationUser,
         OrganizationUser deletingUser,
         SutProvider<OrganizationService> sutProvider)
@@ -1238,12 +1238,12 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
             .Returns(new[] { organizationUser });
 
         var exception = await Assert.ThrowsAsync<BadRequestException>(
-            () => sutProvider.Sut.DeleteUserAsync(deletingUser.OrganizationId, organizationUser.Id, null));
+            () => sutProvider.Sut.RemoveUserAsync(deletingUser.OrganizationId, organizationUser.Id, null));
         Assert.Contains("Organization must have at least one confirmed owner.", exception.Message);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUser_Success(
+    public async Task RemoveUser_Success(
         OrganizationUser organizationUser,
         [OrganizationUser(OrganizationUserStatusType.Confirmed, OrganizationUserType.Owner)] OrganizationUser deletingUser,
         SutProvider<OrganizationService> sutProvider)
@@ -1258,13 +1258,13 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
             .Returns(new[] { deletingUser, organizationUser });
         currentContext.OrganizationOwner(deletingUser.OrganizationId).Returns(true);
 
-        await sutProvider.Sut.DeleteUserAsync(deletingUser.OrganizationId, organizationUser.Id, deletingUser.UserId);
+        await sutProvider.Sut.RemoveUserAsync(deletingUser.OrganizationId, organizationUser.Id, deletingUser.UserId);
 
         await sutProvider.GetDependency<IEventService>().Received(1).LogOrganizationUserEventAsync(organizationUser, EventType.OrganizationUser_Removed);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUser_WithEventSystemUser_Success(
+    public async Task RemoveUser_WithEventSystemUser_Success(
         OrganizationUser organizationUser,
         [OrganizationUser(OrganizationUserStatusType.Confirmed, OrganizationUserType.Owner)] OrganizationUser deletingUser, EventSystemUser eventSystemUser,
         SutProvider<OrganizationService> sutProvider)
@@ -1279,13 +1279,13 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
             .Returns(new[] { deletingUser, organizationUser });
         currentContext.OrganizationOwner(deletingUser.OrganizationId).Returns(true);
 
-        await sutProvider.Sut.DeleteUserAsync(deletingUser.OrganizationId, organizationUser.Id, eventSystemUser);
+        await sutProvider.Sut.RemoveUserAsync(deletingUser.OrganizationId, organizationUser.Id, eventSystemUser);
 
         await sutProvider.GetDependency<IEventService>().Received(1).LogOrganizationUserEventAsync(organizationUser, EventType.OrganizationUser_Removed, eventSystemUser);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUsers_FilterInvalid(OrganizationUser organizationUser, OrganizationUser deletingUser,
+    public async Task RemoveUsers_FilterInvalid(OrganizationUser organizationUser, OrganizationUser deletingUser,
         SutProvider<OrganizationService> sutProvider)
     {
         var organizationUserRepository = sutProvider.GetDependency<IOrganizationUserRepository>();
@@ -1294,12 +1294,12 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
         organizationUserRepository.GetManyAsync(default).ReturnsForAnyArgs(organizationUsers);
 
         var exception = await Assert.ThrowsAsync<BadRequestException>(
-            () => sutProvider.Sut.DeleteUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId));
+            () => sutProvider.Sut.RemoveUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId));
         Assert.Contains("Users invalid.", exception.Message);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUsers_RemoveYourself(
+    public async Task RemoveUsers_RemoveYourself(
         [OrganizationUser(OrganizationUserStatusType.Confirmed, OrganizationUserType.Owner)] OrganizationUser orgUser,
         OrganizationUser deletingUser,
         SutProvider<OrganizationService> sutProvider)
@@ -1310,12 +1310,12 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
         organizationUserRepository.GetManyAsync(default).ReturnsForAnyArgs(organizationUsers);
         organizationUserRepository.GetManyByOrganizationAsync(default, default).ReturnsForAnyArgs(new[] { orgUser });
 
-        var result = await sutProvider.Sut.DeleteUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId);
+        var result = await sutProvider.Sut.RemoveUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId);
         Assert.Contains("You cannot remove yourself.", result[0].Item2);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUsers_NonOwnerRemoveOwner(
+    public async Task RemoveUsers_NonOwnerRemoveOwner(
         [OrganizationUser(type: OrganizationUserType.Admin)] OrganizationUser deletingUser,
         [OrganizationUser(type: OrganizationUserType.Owner)] OrganizationUser orgUser1,
         [OrganizationUser(OrganizationUserStatusType.Confirmed)] OrganizationUser orgUser2,
@@ -1329,12 +1329,12 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
         organizationUserRepository.GetManyAsync(default).ReturnsForAnyArgs(organizationUsers);
         organizationUserRepository.GetManyByOrganizationAsync(default, default).ReturnsForAnyArgs(new[] { orgUser2 });
 
-        var result = await sutProvider.Sut.DeleteUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId);
+        var result = await sutProvider.Sut.RemoveUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId);
         Assert.Contains("Only owners can delete other owners.", result[0].Item2);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUsers_LastOwner(
+    public async Task RemoveUsers_LastOwner(
         [OrganizationUser(status: OrganizationUserStatusType.Confirmed, OrganizationUserType.Owner)] OrganizationUser orgUser,
         SutProvider<OrganizationService> sutProvider)
     {
@@ -1346,12 +1346,12 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
         organizationUserRepository.GetManyByOrganizationAsync(orgUser.OrganizationId, OrganizationUserType.Owner).Returns(organizationUsers);
 
         var exception = await Assert.ThrowsAsync<BadRequestException>(
-            () => sutProvider.Sut.DeleteUsersAsync(orgUser.OrganizationId, organizationUserIds, null));
+            () => sutProvider.Sut.RemoveUsersAsync(orgUser.OrganizationId, organizationUserIds, null));
         Assert.Contains("Organization must have at least one confirmed owner.", exception.Message);
     }
 
     [Theory, BitAutoData]
-    public async Task DeleteUsers_Success(
+    public async Task RemoveUsers_Success(
         [OrganizationUser(OrganizationUserStatusType.Confirmed, OrganizationUserType.Owner)] OrganizationUser deletingUser,
         [OrganizationUser(type: OrganizationUserType.Owner)] OrganizationUser orgUser1, OrganizationUser orgUser2,
         SutProvider<OrganizationService> sutProvider)
@@ -1368,7 +1368,7 @@ OrganizationUserInvite invite, SutProvider<OrganizationService> sutProvider)
             .Returns(new[] { deletingUser, orgUser1 });
         currentContext.OrganizationOwner(deletingUser.OrganizationId).Returns(true);
 
-        await sutProvider.Sut.DeleteUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId);
+        await sutProvider.Sut.RemoveUsersAsync(deletingUser.OrganizationId, organizationUserIds, deletingUser.UserId);
     }
 
     [Theory, BitAutoData]

test/Core.Test/AdminConsole/Services/PolicyServiceTests.cs

@@ -363,20 +363,20 @@ public class PolicyServiceTests
         await sutProvider.Sut.SaveAsync(policy, userService, organizationService, savingUserId);
 
         await organizationService.Received()
-            .DeleteUserAsync(policy.OrganizationId, orgUserDetailUserAcceptedWithout2FA.Id, savingUserId);
+            .RemoveUserAsync(policy.OrganizationId, orgUserDetailUserAcceptedWithout2FA.Id, savingUserId);
         await sutProvider.GetDependency<IMailService>().Received()
             .SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(organization.DisplayName(), orgUserDetailUserAcceptedWithout2FA.Email);
 
         await organizationService.DidNotReceive()
-            .DeleteUserAsync(policy.OrganizationId, orgUserDetailUserInvited.Id, savingUserId);
+            .RemoveUserAsync(policy.OrganizationId, orgUserDetailUserInvited.Id, savingUserId);
         await sutProvider.GetDependency<IMailService>().DidNotReceive()
             .SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(organization.DisplayName(), orgUserDetailUserInvited.Email);
         await organizationService.DidNotReceive()
-            .DeleteUserAsync(policy.OrganizationId, orgUserDetailUserAcceptedWith2FA.Id, savingUserId);
+            .RemoveUserAsync(policy.OrganizationId, orgUserDetailUserAcceptedWith2FA.Id, savingUserId);
         await sutProvider.GetDependency<IMailService>().DidNotReceive()
             .SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(organization.DisplayName(), orgUserDetailUserAcceptedWith2FA.Email);
         await organizationService.DidNotReceive()
-            .DeleteUserAsync(policy.OrganizationId, orgUserDetailAdmin.Id, savingUserId);
+            .RemoveUserAsync(policy.OrganizationId, orgUserDetailAdmin.Id, savingUserId);
         await sutProvider.GetDependency<IMailService>().DidNotReceive()
             .SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(organization.DisplayName(), orgUserDetailAdmin.Email);
 
@@ -471,7 +471,7 @@ public class PolicyServiceTests
         Assert.Contains("Policy could not be enabled. Non-compliant members will lose access to their accounts. Identify members without two-step login from the policies column in the members page.", badRequestException.Message, StringComparison.OrdinalIgnoreCase);
 
         await organizationService.DidNotReceiveWithAnyArgs()
-            .DeleteUserAsync(organizationId: default, organizationUserId: default, deletingUserId: default);
+            .RemoveUserAsync(organizationId: default, organizationUserId: default, deletingUserId: default);
 
         await sutProvider.GetDependency<IMailService>().DidNotReceiveWithAnyArgs()
             .SendOrganizationUserRemovedForPolicyTwoStepEmailAsync(default, default);