Unit test improvements

CacheDrive.Tests/TestDateService.cs → CacheDrive.Tests/Helpers/TestDateService.cs

@@ -1,6 +1,6 @@
 using CacheDrive.Services;
 
-namespace CacheDrive.Tests;
+namespace CacheDrive.Tests.Helpers;
 
 public class TestDateService(DateTime utcNow) : IDateService
 {

CacheDrive.Tests/TestHelper.cs → CacheDrive.Tests/Helpers/TestHelper.cs

@@ -3,7 +3,7 @@
 using CacheDrive.Services;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace CacheDrive.Tests;
+namespace CacheDrive.Tests.Helpers;
 
 public static class TestHelper
 {

CacheDrive.Tests/UnitTest1.cs → CacheDrive.Tests/MemoryAndFileTests.cs

@@ -1,11 +1,12 @@
 using CacheDrive.Models;
 using CacheDrive.Services;
+using CacheDrive.Tests.Helpers;
 using FluentAssertions;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace CacheDrive.Tests;
 
-public class Tests
+public class MemoryAndFileTests
 {
     [Test, Order(1)]
     public async Task CacheShouldBeSavedCorrectly()

CacheDrive.Tests/MemoryTests.cs

@@ -0,0 +1,30 @@
+using CacheDrive.Configuration;
+using CacheDrive.Models;
+using CacheDrive.Services;
+using CacheDrive.Tests.Helpers;
+using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CacheDrive.Tests;
+
+public class MemoryTests
+{
+    [TestCase("key1", "one")]
+    [TestCase("key2","Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")]
+    public async Task StringShouldBeCorrectlySavedAndReadFromTheCacheInMemory(string key, string text)
+    {
+        ServiceProvider serviceProvider = TestHelper.CreateServiceProvider(DateTime.Now, true, CacheExpirationType.Hours, 2, CacheType.Memory);
+
+        ICacheService cacheService = serviceProvider.GetRequiredService<ICacheService>();
+
+        await cacheService.InitializeAsync();
+
+        await cacheService.SetAsync(SpecificField.Create(key, text));
+
+        var cachedSpecificField =  await cacheService.GetAsync<SpecificField>(SpecificField.GetCacheKey(key));
+
+        await cacheService.FlushAsync();
+
+        cachedSpecificField.Value.Should().Be(text);
+    }
+}

CacheDrive/Extensions/ServiceCollectionExtensions.cs

@@ -1,25 +1,24 @@
+using System;
 using CacheDrive.Configuration;
 using CacheDrive.Services;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 
 namespace CacheDrive.Extensions;
 
 public static class ServiceCollectionExtensions
 {
     public static void RegisterCacheDrive(this IServiceCollection services, CacheSettings settings = null)
     {
-        RegisterIpGeolocation(services, null, null, settings);
+        RegisterCacheDrive(services, null, null, settings);
     }
 
-    public static void RegisterIpGeolocation(this IServiceCollection services,
+    public static void RegisterCacheDrive(this IServiceCollection services,
         IConfiguration configuration = null,
         string configurationSectionName = null,
         CacheSettings settings = null)
     {
-        services.AddSingleton<IDateService, DateService>();
-        services.AddSingleton<ICacheService, MemoryCacheFileStorageService>();
-
         if (configuration is not null)
         {
             if (string.IsNullOrEmpty(configurationSectionName))
@@ -61,5 +60,20 @@ public static void RegisterIpGeolocation(this IServiceCollection services,
             }
         }
 
+        services.AddSingleton<IDateService, DateService>();
+
+        services.AddSingleton<ICacheService>(serviceProvider =>
+        {
+            return serviceProvider.GetService<IOptions<CacheSettings>>().Value.CacheType switch
+            {
+                CacheType.Memory => new MemoryCacheService(
+                    serviceProvider.GetRequiredService<IOptions<CacheSettings>>(),
+                    serviceProvider.GetRequiredService<IDateService>()),
+                CacheType.MemoryAndFile => new MemoryCacheFileStorageService(
+                    serviceProvider.GetRequiredService<IOptions<CacheSettings>>(),
+                    serviceProvider.GetRequiredService<IDateService>()),
+                _ => throw new ArgumentOutOfRangeException()
+            };
+        });
     }
 }

CacheDrive/Services/MemoryCacheService.cs

@@ -14,14 +14,14 @@ internal class MemoryCacheService : ICacheService
     private readonly IDateService _dateService;
     internal readonly ConcurrentDictionary<string, CachedItem> Storage = new();
 
-    private readonly CacheSettings _ipGeolocationSettings;
+    private readonly CacheSettings _cacheSettings;
 
     private int _cacheExpirationInSeconds;
 
     public MemoryCacheService(IOptions<CacheSettings> settings, IDateService dateService)
     {
         _dateService = dateService;
-        _ipGeolocationSettings = settings?.Value;
+        _cacheSettings = settings?.Value;
         CalculateCacheExpiration();
     }
 
@@ -175,7 +175,7 @@ public virtual Task FlushAsync()
 
     public virtual Task InitializeAsync()
         => Task.CompletedTask;
-    
+
     private CachedItem Get(ICacheable item)
         => Get(item.CacheKey);
 
@@ -184,12 +184,12 @@ private CachedItem Get(string key)
 
     private void CalculateCacheExpiration()
     {
-        _cacheExpirationInSeconds = _ipGeolocationSettings.CacheExpirationType switch
+        _cacheExpirationInSeconds = _cacheSettings.CacheExpirationType switch
         {
-            CacheExpirationType.Seconds => _ipGeolocationSettings.CacheExpiration,
-            CacheExpirationType.Minutes => _ipGeolocationSettings.CacheExpiration * 60,
-            CacheExpirationType.Hours => _ipGeolocationSettings.CacheExpiration * 60 * 60,
-            CacheExpirationType.Days => _ipGeolocationSettings.CacheExpiration * 60 * 60 * 24,
+            CacheExpirationType.Seconds => _cacheSettings.CacheExpiration,
+            CacheExpirationType.Minutes => _cacheSettings.CacheExpiration * 60,
+            CacheExpirationType.Hours => _cacheSettings.CacheExpiration * 60 * 60,
+            CacheExpirationType.Days => _cacheSettings.CacheExpiration * 60 * 60 * 24,
             CacheExpirationType.Never => -1,
             _ => throw new ArgumentOutOfRangeException()
         };
@@ -199,7 +199,7 @@ private TimeSpan GetExpirationLength(int expirySeconds = 0)
     {
         if (expirySeconds == 0)
         {
-            return _ipGeolocationSettings.CacheExpirationType == CacheExpirationType.Never
+            return _cacheSettings.CacheExpirationType == CacheExpirationType.Never
                 ? TimeSpan.FromDays(365 * 1000)
                 : TimeSpan.FromSeconds(_cacheExpirationInSeconds);
         }