[PS-1928] Add BumpAccountRevisionDate methods (#2458)

* Move RevisionDate Bumps to Extension Class

* Add Tests against live databases

* Run Formatting

* Fix Typo

* Fix Test Solution Typo

* Await ReplaceAsync

test/Infrastructure.IntegrationTest/Repositories/CipherRepositoryTests.cs

@@ -0,0 +1,97 @@
+using Bit.Core.Entities;
+using Bit.Core.Enums;
+using Bit.Core.Repositories;
+using Core.Models.Data;
+using Xunit;
+
+namespace Bit.Infrastructure.IntegrationTest.Repositories;
+
+public class CipherRepositoryTests
+{
+    [DatabaseTheory, DatabaseData]
+    public async Task DeleteAsync_UpdatesUserRevisionDate(
+        IUserRepository userRepository,
+        ICipherRepository cipherRepository,
+        ITestDatabaseHelper helper)
+    {
+        var user = await userRepository.CreateAsync(new User
+        {
+            Name = "Test User",
+            Email = "test@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var cipher = await cipherRepository.CreateAsync(new Cipher
+        {
+            Type = CipherType.Login,
+            UserId = user.Id,
+        });
+
+        helper.ClearTracker();
+
+        await cipherRepository.DeleteAsync(cipher);
+
+        var deletedCipher = await cipherRepository.GetByIdAsync(cipher.Id);
+
+        Assert.Null(deletedCipher);
+        var updatedUser = await userRepository.GetByIdAsync(user.Id);
+        Assert.NotEqual(updatedUser.AccountRevisionDate, user.AccountRevisionDate);
+    }
+
+    [DatabaseTheory, DatabaseData]
+    public async Task CreateAsync_UpdateWithCollecitons_Works(
+        IUserRepository userRepository,
+        IOrganizationRepository organizationRepository,
+        IOrganizationUserRepository organizationUserRepository,
+        ICollectionRepository collectionRepository,
+        ICipherRepository cipherRepository,
+        ICollectionCipherRepository collectionCipherRepository,
+        ITestDatabaseHelper helper)
+    {
+        var user = await userRepository.CreateAsync(new User
+        {
+            Name = "Test User",
+            Email = "test@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var organization = await organizationRepository.CreateAsync(new Organization
+        {
+            Name = "Test Organization",
+        });
+
+        await organizationUserRepository.CreateAsync(new OrganizationUser
+        {
+            UserId = user.Id,
+            OrganizationId = organization.Id,
+            Status = OrganizationUserStatusType.Accepted,
+            Type = OrganizationUserType.Owner,
+        });
+
+        var collection = await collectionRepository.CreateAsync(new Collection
+        {
+            Name = "Test Collection",
+            OrganizationId = organization.Id
+        });
+
+        helper.ClearTracker();
+
+        await cipherRepository.CreateAsync(new CipherDetails
+        {
+            Type = CipherType.Login,
+            OrganizationId = organization.Id,
+        }, new List<Guid>
+        {
+            collection.Id,
+        });
+
+        var updatedUser = await userRepository.GetByIdAsync(user.Id);
+
+        Assert.NotEqual(updatedUser.AccountRevisionDate, user.AccountRevisionDate);
+
+        var collectionCiphers = await collectionCipherRepository.GetManyByOrganizationIdAsync(organization.Id);
+        Assert.NotEmpty(collectionCiphers);
+    }
+}

test/Infrastructure.IntegrationTest/Repositories/EmergencyAccessRepositoryTests.cs

@@ -0,0 +1,46 @@
+using Bit.Core.Entities;
+using Bit.Core.Enums;
+using Bit.Core.Repositories;
+using Xunit;
+
+namespace Bit.Infrastructure.IntegrationTest.Repositories;
+
+public class EmergencyAccessRepositoriesTests
+{
+    [DatabaseTheory, DatabaseData]
+    public async Task DeleteAsync_UpdatesRevisionDate(IUserRepository userRepository,
+      IEmergencyAccessRepository emergencyAccessRepository,
+      ITestDatabaseHelper helper)
+    {
+        var grantorUser = await userRepository.CreateAsync(new User
+        {
+            Name = "Test Grantor User",
+            Email = "test+grantor@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var granteeUser = await userRepository.CreateAsync(new User
+        {
+            Name = "Test Grantee User",
+            Email = "test+grantee@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var emergencyAccess = await emergencyAccessRepository.CreateAsync(new EmergencyAccess
+        {
+            GrantorId = grantorUser.Id,
+            GranteeId = granteeUser.Id,
+            Status = EmergencyAccessStatusType.Confirmed,
+        });
+
+        helper.ClearTracker();
+
+        await emergencyAccessRepository.DeleteAsync(emergencyAccess);
+
+        var updatedGrantee = await userRepository.GetByIdAsync(granteeUser.Id);
+
+        Assert.NotEqual(updatedGrantee.AccountRevisionDate, granteeUser.AccountRevisionDate);
+    }
+}

test/Infrastructure.IntegrationTest/Repositories/OrganizationUserRepositoryTests.cs

@@ -0,0 +1,97 @@
+using Bit.Core.Entities;
+using Bit.Core.Enums;
+using Bit.Core.Repositories;
+using Xunit;
+
+namespace Bit.Infrastructure.IntegrationTest.Repositories;
+
+public class OrganizationUserRepositoryTests
+{
+    [DatabaseTheory, DatabaseData]
+    public async Task DeleteAsync_Works(IUserRepository userRepository,
+        IOrganizationRepository organizationRepository,
+        IOrganizationUserRepository organizationUserRepository,
+        ITestDatabaseHelper helper)
+    {
+        var user = await userRepository.CreateAsync(new User
+        {
+            Name = "Test User",
+            Email = "test@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var organization = await organizationRepository.CreateAsync(new Organization
+        {
+            Name = "Test Org",
+        });
+
+        var orgUser = await organizationUserRepository.CreateAsync(new OrganizationUser
+        {
+            OrganizationId = organization.Id,
+            UserId = user.Id,
+            Status = OrganizationUserStatusType.Confirmed,
+        });
+
+        helper.ClearTracker();
+
+        await organizationUserRepository.DeleteAsync(orgUser);
+
+        var newUser = await userRepository.GetByIdAsync(user.Id);
+        Assert.NotEqual(newUser.AccountRevisionDate, user.AccountRevisionDate);
+    }
+
+    [DatabaseTheory, DatabaseData]
+    public async Task DeleteManyAsync_Works(IUserRepository userRepository,
+        IOrganizationRepository organizationRepository,
+        IOrganizationUserRepository organizationUserRepository,
+        ITestDatabaseHelper helper)
+    {
+        var user1 = await userRepository.CreateAsync(new User
+        {
+            Name = "Test User 1",
+            Email = "test1@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var user2 = await userRepository.CreateAsync(new User
+        {
+            Name = "Test User 2",
+            Email = "test1@email.com",
+            ApiKey = "TEST",
+            SecurityStamp = "stamp",
+        });
+
+        var organization = await organizationRepository.CreateAsync(new Organization
+        {
+            Name = "Test Org",
+        });
+
+        var orgUser1 = await organizationUserRepository.CreateAsync(new OrganizationUser
+        {
+            OrganizationId = organization.Id,
+            UserId = user1.Id,
+        });
+
+        var orgUser2 = await organizationUserRepository.CreateAsync(new OrganizationUser
+        {
+            OrganizationId = organization.Id,
+            UserId = user2.Id,
+        });
+
+        helper.ClearTracker();
+
+        await organizationUserRepository.DeleteManyAsync(new List<Guid>
+        {
+            orgUser1.Id,
+            orgUser2.Id,
+        });
+
+        var updatedUser1 = await userRepository.GetByIdAsync(user1.Id);
+        var updatedUser2 = await userRepository.GetByIdAsync(user2.Id);
+
+        Assert.NotEqual(updatedUser1.AccountRevisionDate, user1.AccountRevisionDate);
+        Assert.NotEqual(updatedUser2.AccountRevisionDate, user2.AccountRevisionDate);
+    }
+}