updates to unit tests

src/api/SecretsSharingTool.Core.Tests/Handlers/BaseHandlerTest.cs

@@ -1,5 +1,7 @@
 using MediatR;
 using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using SecretsSharingTool.Core.Interfaces;
 using SecretsSharingTool.Core.Tests.Database;
 using SecretsSharingTool.Data;
 
@@ -26,13 +28,15 @@ protected IMediator Mediator
 
     protected readonly IServiceCollection ServiceCollection;
     protected readonly ServiceProvider ServiceProvider;
+    protected readonly Mock<IDateTimeProvider> MockDateTimeProvider = new ();
 
     protected BaseHandlerTest(DatabaseFixture fixture)
     {
         ServiceCollection = new ServiceCollection();
         ServiceCollection.AddLogging();
         ServiceCollection.AddDatabase(fixture.Configuration.BuildConnectionString(true));
         ServiceCollection.AddCoreServices();
+        ServiceCollection.AddSingleton(MockDateTimeProvider.Object);
 
         ConfigureAdditionalServices();
 

src/api/SecretsSharingTool.Core.Tests/Handlers/Secret/Cleanse/CleanseSecretsCommandHandlerTests.cs

@@ -6,7 +6,13 @@ namespace SecretsSharingTool.Core.Tests.Handlers.Secret.Cleanse;
 
 public class CleanseSecretsCommandHandlerTests : BaseHandlerTest
 {
-    public CleanseSecretsCommandHandlerTests(DatabaseFixture fixture) : base(fixture) { }
+    public CleanseSecretsCommandHandlerTests(DatabaseFixture fixture) : base(fixture)
+    {
+        MockDateTimeProvider.Setup(p => p.GetCurrentDateTimeOffset())
+            .Returns(_testTime);
+    }
+
+    private readonly DateTimeOffset _testTime = DateTimeOffset.UtcNow;
 
     [Fact]
     public async Task Handle_WhenSecretsAreExpired_DeactivatesSecrets()
@@ -17,14 +23,14 @@ public async Task Handle_WhenSecretsAreExpired_DeactivatesSecrets()
             {
                 EncryptedMessage = new [] { (byte) 0 },
                 IsActive = true,
-                CreatedOn = DateTimeOffset.UtcNow,
+                CreatedOn = _testTime,
                 ExpiryMinutes = 10
             },
             new ()
             {
                 EncryptedMessage = new [] { (byte) 1 },
                 IsActive = true,
-                CreatedOn = DateTimeOffset.UtcNow.AddMinutes(-9),
+                CreatedOn = _testTime.AddMinutes(-9).AddSeconds(-59),
                 ExpiryMinutes = 10
             },
         };
@@ -35,14 +41,14 @@ public async Task Handle_WhenSecretsAreExpired_DeactivatesSecrets()
             {
                 EncryptedMessage = new [] { (byte) 2 },
                 IsActive = false,
-                CreatedOn = DateTimeOffset.UtcNow,
+                CreatedOn = _testTime,
                 ExpiryMinutes = 10
             },
             new ()
             {
                 EncryptedMessage = new [] { (byte) 3 },
                 IsActive = true,
-                CreatedOn = DateTimeOffset.UtcNow.AddMinutes(-11),
+                CreatedOn = _testTime.AddMinutes(-11),
                 ExpiryMinutes = 10
             },
         };
@@ -70,14 +76,14 @@ public async Task Handle_WhenNoSecretsExpired_AllSecretsAreActive()
             {
                 EncryptedMessage = new [] { (byte) 0 },
                 IsActive = true,
-                CreatedOn = DateTimeOffset.UtcNow.AddMinutes(-5),
+                CreatedOn = _testTime.AddMinutes(-5),
                 ExpiryMinutes = 10
             },
             new ()
             {
                 EncryptedMessage = new [] { (byte) 1 },
                 IsActive = true,
-                CreatedOn = DateTimeOffset.UtcNow.AddMinutes(-9),
+                CreatedOn = _testTime.AddMinutes(-9),
                 ExpiryMinutes = 10
             },
         };
@@ -106,7 +112,7 @@ public async Task Handle_WithLargeNumberOfSecretsToExpire_ExpiresAllSecrets()
             {
                 EncryptedMessage = new [] { (byte) 0 },
                 IsActive = false,
-                CreatedOn = DateTimeOffset.UtcNow,
+                CreatedOn = _testTime,
                 ExpiryMinutes = 10
             });
         }

src/api/SecretsSharingTool.Core.Tests/Handlers/Secret/Retrieve/RetrieveSecretCommandHandlerTests.cs

@@ -229,7 +229,7 @@ private static HttpContext CreateFakeHttpContext()
         };
     }
 
-    private void TestAuditRecordUserAgentAndIpAddress(SecretAccessAudit audit)
+    private void TestAuditRecordUserAgentAndIpAddress(Models.SecretAccessAudit audit)
     {
         audit.ClientUserAgent.Should().Be("Test Browser");
         audit.ClientIpAddress.Should().Be("109.142.41.4");

src/api/SecretsSharingTool.Core.Tests/Handlers/SecretAccessAudit/Cleanse/CleanseSecretAccessAuditsCommandHandlerTests.cs

@@ -0,0 +1,92 @@
+using Microsoft.EntityFrameworkCore;
+using SecretsSharingTool.Core.Handlers.SecretAccessAudit.Cleanse;
+using SecretsSharingTool.Core.Tests.Database;
+
+namespace SecretsSharingTool.Core.Tests.Handlers.SecretAccessAudit.Cleanse;
+
+public class CleanseSecretAccessAuditsCommandHandlerTests : BaseHandlerTest
+{
+    public CleanseSecretAccessAuditsCommandHandlerTests(DatabaseFixture fixture) : base(fixture)
+    {
+        MockDateTimeProvider.Setup(p => p.GetCurrentDateTimeOffset())
+            .Returns(_testTime);
+    }
+
+    private readonly DateTimeOffset _testTime = DateTimeOffset.UtcNow;
+
+    [Fact]
+    public async Task Handle_WhenSecretAccessAuditsAreExpired_DeactivatesSecretAccessAudits()
+    {
+        var activeAudits = new List<Models.SecretAccessAudit>
+        {
+            NewSecretAccessAudit(_testTime),
+            NewSecretAccessAudit(_testTime.AddDays(-180)),
+        };
+
+        var expiredAudits = new List<Models.SecretAccessAudit>
+        {
+            NewSecretAccessAudit(_testTime.AddDays(-180).AddMilliseconds(-1)),
+            NewSecretAccessAudit(_testTime.AddDays(-181)),
+        };
+
+        await Database.AuditRecords.AddRangeAsync(activeAudits);
+        await Database.AuditRecords.AddRangeAsync(expiredAudits);
+        await Database.SaveChangesAsync();
+
+        await Mediator.Send(new CleanseSecretAccessAuditsCommand());
+
+        var emptySecrets = await Database.AuditRecords.ToListAsync();
+
+        expiredAudits.ForEach(p =>
+            emptySecrets.FirstOrDefault(x => x.Id == p.Id)
+                .Should()
+                .BeNull());
+    }
+
+    [Fact]
+    public async Task Handle_WhenNoSecretAuditRecordsExpired_AllAuditRecordsArePresent()
+    {
+        var activeAudits = new List<Models.SecretAccessAudit>
+        {
+            NewSecretAccessAudit(_testTime),
+            NewSecretAccessAudit(_testTime.AddDays(-180)),
+        };
+
+        await Database.AuditRecords.AddRangeAsync(activeAudits);
+        await Database.SaveChangesAsync();
+
+        await Mediator.Send(new CleanseSecretAccessAuditsCommand());
+
+        var dbSecrets = await Database.AuditRecords.ToListAsync();
+        activeAudits.ForEach(p =>
+            dbSecrets.FirstOrDefault(x => x.Id == p.Id)
+                .Should()
+                .NotBeNull());
+    }
+
+    [Fact]
+    public async Task Handle_WithLargeNumberOfSecretAuditRecordsToExpire_DeletesAllAuditRecords()
+    {
+        var auditRecordsList = new List<Models.SecretAccessAudit>();
+
+        for (var i = 0; i < 105; i++)
+        {
+            auditRecordsList.Add(NewSecretAccessAudit(_testTime.AddDays(-181)));
+        }
+
+        await Database.AuditRecords.AddRangeAsync(auditRecordsList);
+        await Database.SaveChangesAsync();
+
+        await Mediator.Send(new CleanseSecretAccessAuditsCommand());
+
+        var auditRecords = await Database.AuditRecords.ToListAsync();
+
+        auditRecordsList.Count.Should().Be(105);
+
+        auditRecordsList.ForEach(p => auditRecords.FirstOrDefault(q => q.Id == p.Id).Should().BeNull());
+    }
+
+    private Models.SecretAccessAudit NewSecretAccessAudit(DateTimeOffset createdOn) => new()
+        { ClientIpAddress = "", ClientUserAgent = "", CreatedOn = createdOn };
+
+}

src/api/SecretsSharingTool.Core/DependencyInjection.cs

@@ -3,6 +3,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using SecretsSharingTool.Core.Interfaces;
 using SecretsSharingTool.Core.Pipelines;
+using SecretsSharingTool.Core.Providers;
 
 namespace SecretsSharingTool.Core;
 
@@ -19,4 +20,10 @@ public static IServiceCollection AddCoreServices(this IServiceCollection service
         services.AddScoped(typeof(IPipelineBehavior<,>), typeof(ValidationPipelineBehavior<,>));
         return services;
     }
+
+    public static IServiceCollection AddDateTimeProvider(this IServiceCollection services)
+    {
+        services.AddSingleton<IDateTimeProvider, DateTimeProvider>();
+        return services;
+    }
 }

src/api/SecretsSharingTool.Core/Handlers/Secret/Cleanse/CleanseSecretsCommand.cs

@@ -2,6 +2,6 @@
 
 namespace SecretsSharingTool.Core.Handlers.Secret.Cleanse;
 
-public class CleanseSecretsCommand : IRequest
+public sealed class CleanseSecretsCommand : IRequest
 {
 }

src/api/SecretsSharingTool.Core/Handlers/Secret/Cleanse/CleanseSecretsCommandHandler.cs

@@ -1,24 +1,27 @@
 using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using SecretsSharingTool.Core.Interfaces;
 using SecretsSharingTool.Data;
 
 namespace SecretsSharingTool.Core.Handlers.Secret.Cleanse;
 
 public class CleanseSecretsCommandHandler : BaseRequestHandler<CleanseSecretsCommand>
 {
-    public CleanseSecretsCommandHandler(AppUnitOfWork appUnitOfWork, ILogger<CleanseSecretsCommandHandler> logger) : base(appUnitOfWork, logger)
+    public CleanseSecretsCommandHandler(AppUnitOfWork appUnitOfWork, ILogger<CleanseSecretsCommandHandler> logger, IDateTimeProvider dateTimeProvider) : base(appUnitOfWork, logger)
     {
+        _dateTimeProvider = dateTimeProvider;
     }
 
+    private readonly IDateTimeProvider _dateTimeProvider;
     private const int BatchSize = 50;
 
     public override async Task<Unit> Handle(CleanseSecretsCommand request, CancellationToken cancellationToken)
     {
         var expiredSecrets = AppUnitOfWork.Secrets.Where(p => p.EncryptedMessage != null
                                                                   && (!p.IsActive ||
                                                                       p.CreatedOn.AddMinutes(p.ExpiryMinutes) <
-                                                                      DateTimeOffset.UtcNow));
+                                                                      _dateTimeProvider.GetCurrentDateTimeOffset()));
 
         var count = await expiredSecrets.CountAsync(cancellationToken);
         var batches = (count / BatchSize) + 1;

src/api/SecretsSharingTool.Core/Handlers/Secret/Retrieve/RetrieveSecretCommandHandler.cs

@@ -105,7 +105,7 @@ private async Task<bool> ValidateSecretState(RetrieveSecretCommand request, Mode
     private async Task CreateAuditRecordForState(Guid secretId, FailureReason? failureReason = null)
     {
         var httpContext = _httpContextAccessor.HttpContext;
-        await Database.AuditRecords.AddAsync(new SecretAccessAudit()
+        await Database.AuditRecords.AddAsync(new Models.SecretAccessAudit()
         {
             SecretId = secretId,
             FailureReason = failureReason,

src/api/SecretsSharingTool.Core/Handlers/SecretAccessAudit/Cleanse/CleanseSecretAccessAuditsCommand.cs

@@ -0,0 +1,7 @@
+using MediatR;
+
+namespace SecretsSharingTool.Core.Handlers.SecretAccessAudit.Cleanse;
+
+public sealed class CleanseSecretAccessAuditsCommand : IRequest
+{
+}

src/api/SecretsSharingTool.Core/Handlers/SecretAccessAudit/Cleanse/CleanseSecretAccessAuditsCommandHandler.cs

@@ -0,0 +1,36 @@
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using SecretsSharingTool.Core.Interfaces;
+using SecretsSharingTool.Data;
+
+namespace SecretsSharingTool.Core.Handlers.SecretAccessAudit.Cleanse;
+
+public sealed class CleanseSecretAccessAuditsCommandHandler : BaseRequestHandler<CleanseSecretAccessAuditsCommand>
+{
+    public CleanseSecretAccessAuditsCommandHandler(AppUnitOfWork db, ILogger<CleanseSecretAccessAuditsCommandHandler> logger, IDateTimeProvider dateTimeProvider) : base(db, logger)
+    {
+        _dateTimeProvider = dateTimeProvider;
+    }
+
+    private readonly IDateTimeProvider _dateTimeProvider;
+    private const int BatchSize = 50;
+
+    public override async Task<Unit> Handle(CleanseSecretAccessAuditsCommand command, CancellationToken cancellationToken)
+    {
+        var expiredAudits = AppUnitOfWork.AuditRecords.Where(p => p.CreatedOn.AddDays(180) <
+                                                                  _dateTimeProvider.GetCurrentDateTimeOffset());
+
+        var count = await expiredAudits.CountAsync(cancellationToken);
+        var batches = (count / BatchSize) + 1;
+
+        for (var i = 0; i < batches; i++)
+        {
+            var batch = await expiredAudits.Take(BatchSize).ToListAsync(cancellationToken);
+            AppUnitOfWork.AuditRecords.RemoveRange(batch);
+            await AppUnitOfWork.SaveChangesAsync(cancellationToken);
+        }
+
+        return Unit.Value;
+    }
+}

src/api/SecretsSharingTool.Core/Interfaces/IDateTimeProvider.cs

@@ -0,0 +1,7 @@
+namespace SecretsSharingTool.Core.Interfaces;
+
+public interface IDateTimeProvider
+{
+    public DateTimeOffset GetCurrentDateTimeOffset();
+    public DateTime GetCurrentDateTime();
+}

src/api/SecretsSharingTool.Core/Providers/DateTimeProvider.cs

@@ -0,0 +1,10 @@
+using SecretsSharingTool.Core.Interfaces;
+
+namespace SecretsSharingTool.Core.Providers;
+
+public class DateTimeProvider : IDateTimeProvider
+{
+    public DateTimeOffset GetCurrentDateTimeOffset() => DateTimeOffset.UtcNow;
+
+    public DateTime GetCurrentDateTime() => DateTime.UtcNow;
+}

src/api/SecretsSharingTool.Web.Tests/HostedServices/BaseHostedServiceTests.cs

@@ -0,0 +1,24 @@
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using SecretsSharingTool.Web.HostedServices;
+
+namespace SecretsSharingTool.Web.Tests.HostedServices;
+
+public abstract class BaseHostedServiceTests<TService> where TService : BaseHostedService<TService>
+{
+    protected readonly Mock<IMediator> MockMediator = new ();
+    private readonly IServiceProvider _serviceProvider;
+
+    protected BaseHostedServiceTests()
+    {
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddLogging();
+        serviceCollection.AddSingleton(MockMediator.Object);
+        serviceCollection.AddTransient<TService>();
+
+        _serviceProvider = serviceCollection.BuildServiceProvider();
+    }
+
+    protected TService GetService() => _serviceProvider.GetService<TService>()!;
+}

src/api/SecretsSharingTool.Web.Tests/HostedServices/CleanseSecretAccessAuditsHostedServiceTests.cs

@@ -0,0 +1,16 @@
+using Moq;
+using SecretsSharingTool.Core.Handlers.SecretAccessAudit.Cleanse;
+using SecretsSharingTool.Web.HostedServices;
+
+namespace SecretsSharingTool.Web.Tests.HostedServices;
+
+public class CleanseSecretAccessAuditsHostedServiceTests : BaseHostedServiceTests<CleanseSecretAccessAuditsHostedService>
+{
+    [Fact]
+    public async Task StartAsync_WhenCalled_InvokesMediatrCall()
+    {
+        using var service = GetService();
+        await service.StartAsync(new CancellationToken());
+        MockMediator.Verify(p => p.Send(It.IsAny<CleanseSecretAccessAuditsCommand>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+}

src/api/SecretsSharingTool.Web.Tests/HostedServices/CleanseSecretsHostedServiceTests.cs

@@ -0,0 +1,16 @@
+using Moq;
+using SecretsSharingTool.Core.Handlers.Secret.Cleanse;
+using SecretsSharingTool.Web.HostedServices;
+
+namespace SecretsSharingTool.Web.Tests.HostedServices;
+
+public class CleanseSecretsHostedServiceTests : BaseHostedServiceTests<CleanseSecretsHostedService>
+{
+    [Fact]
+    public async Task StartAsync_WhenCalled_InvokesMediatrCall()
+    {
+        using var service = GetService();
+        await service.StartAsync(new CancellationToken());
+        MockMediator.Verify(p => p.Send(It.IsAny<CleanseSecretsCommand>(), It.IsAny<CancellationToken>()), Times.Once);
+    }
+}