Fixed default cache duration not getting applied to instance methods

Added unit tests
touchofevil-dev · May 12, 2023 · c4a2f79 · c4a2f79
1 parent 633b570
commit c4a2f79
Show file tree

Hide file tree

Showing 6 changed files with 252 additions and 2 deletions.
diff --git a/LazyCache.UnitTestsCore21/CachingServiceTests.cs b/LazyCache.UnitTestsCore21/CachingServiceTests.cs
@@ -1,6 +1,8 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using NUnit.Framework;
+using System.Threading.Tasks;
+using System;
 
 namespace LazyCache.UnitTestsCore21
 {
@@ -32,5 +34,53 @@ public void GetOrAddOnCore21ReturnsTheCachedItem()
             Assert.IsNotNull(cachedResult);
             Assert.AreEqual("SomeValue", cachedResult.SomeProperty);
         }
+
+        [Test]
+        public async Task GetOrAddAsyncOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
+
+        [Test]
+        public async Task GetOrAddOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
     }
 }
diff --git a/LazyCache.UnitTestsCore22/CachingServiceTests.cs b/LazyCache.UnitTestsCore22/CachingServiceTests.cs
@@ -1,6 +1,8 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using NUnit.Framework;
+using System.Threading.Tasks;
+using System;
 
 namespace LazyCache.UnitTestsCore22
 {
@@ -32,5 +34,53 @@ public void GetOrAddOnCore22ReturnsTheCachedItem()
             Assert.IsNotNull(cachedResult);
             Assert.AreEqual("SomeValue", cachedResult.SomeProperty);
         }
+
+        [Test]
+        public async Task GetOrAddAsyncOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
+
+        [Test]
+        public async Task GetOrAddOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
     }
 }
diff --git a/LazyCache.UnitTestsCore30/CachingServiceTests.cs b/LazyCache.UnitTestsCore30/CachingServiceTests.cs
@@ -1,6 +1,8 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using NUnit.Framework;
+using System.Threading.Tasks;
+using System;
 
 namespace LazyCache.UnitTestsCore30
 {
@@ -32,5 +34,53 @@ public void GetOrAddOnCore30ReturnsTheCachedItem()
             Assert.IsNotNull(cachedResult);
             Assert.AreEqual("SomeValue", cachedResult.SomeProperty);
         }
+
+        [Test]
+        public async Task GetOrAddAsyncOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
+
+        [Test]
+        public async Task GetOrAddOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
     }
 }
diff --git a/LazyCache.UnitTestsCore31/CachingServiceTests.cs b/LazyCache.UnitTestsCore31/CachingServiceTests.cs
@@ -1,6 +1,8 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using NUnit.Framework;
+using System.Threading.Tasks;
+using System;
 
 namespace LazyCache.UnitTestsCore31
 {
@@ -32,5 +34,53 @@ public void GetOrAddOnCore31ReturnsTheCachedItem()
             Assert.IsNotNull(cachedResult);
             Assert.AreEqual("SomeValue", cachedResult.SomeProperty);
         }
+
+        [Test]
+        public async Task GetOrAddAsyncOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
+
+        [Test]
+        public async Task GetOrAddOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
     }
 }
diff --git a/LazyCache.UnitTestsNet50/CachingServiceTests.cs b/LazyCache.UnitTestsNet50/CachingServiceTests.cs
@@ -1,6 +1,8 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using NUnit.Framework;
+using System.Threading.Tasks;
+using System;
 
 namespace LazyCache.UnitTestsNet50
 {
@@ -32,5 +34,53 @@ public void GetOrAddOnNet50ReturnsTheCachedItem()
             Assert.IsNotNull(cachedResult);
             Assert.AreEqual("SomeValue", cachedResult.SomeProperty);
         }
+
+        [Test]
+        public async Task GetOrAddAsyncOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAddAsync("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
+
+        [Test]
+        public async Task GetOrAddOnCore21DefaultCacheDurationHonoured()
+        {
+            sut.DefaultCachePolicy.DefaultCacheDurationSeconds = 1;
+
+            int value = DateTime.UtcNow.Second;
+            int result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+
+            Assert.AreEqual(value, result);
+
+            // wait for the item to expire
+            await Task.Delay(TimeSpan.FromSeconds(2));
+
+            // same key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("foo", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+
+            // new key
+            value = DateTime.UtcNow.Second;
+            result = await sut.GetOrAdd("bar", x => Task.FromResult(value));
+            Assert.AreEqual(value, result);
+        }
     }
 }
diff --git a/LazyCache/CachingService.cs b/LazyCache/CachingService.cs
@@ -97,7 +97,7 @@ public virtual bool TryGetValue<T>(string key, out T value)
 
         public virtual T GetOrAdd<T>(string key, Func<ICacheEntry, T> addItemFactory)
         {
-            return GetOrAdd(key, addItemFactory, null);
+            return GetOrAdd(key, addItemFactory, DefaultCachePolicy.BuildOptions());
         }
 
         public virtual T GetOrAdd<T>(string key, Func<ICacheEntry, T> addItemFactory, MemoryCacheEntryOptions policy)
@@ -180,7 +180,7 @@ public virtual void Remove(string key)
 
         public virtual Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory)
         {
-            return GetOrAddAsync(key, addItemFactory, null);
+            return GetOrAddAsync(key, addItemFactory, DefaultCachePolicy.BuildOptions());
         }
 
         public virtual async Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory,