Fixed default cache duration not getting applied to instance methods

touchofevil-dev · touchofevil-dev · commit c4a2f7909d26 · 2023-05-12T22:02:42.000+05:30
Added unit tests
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,

Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ public virtual bool TryGetValue<T>(string key, out T value)`
`97`	`97`
`98`	`98`	`public virtual T GetOrAdd<T>(string key, Func<ICacheEntry, T> addItemFactory)`
`99`	`99`	`{`
`100`		`- return GetOrAdd(key, addItemFactory, null);`
	`100`	`+ return GetOrAdd(key, addItemFactory, DefaultCachePolicy.BuildOptions());`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`public virtual T GetOrAdd<T>(string key, Func<ICacheEntry, T> addItemFactory, MemoryCacheEntryOptions policy)`
`@@ -180,7 +180,7 @@ public virtual void Remove(string key)`
`180`	`180`
`181`	`181`	`public virtual Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory)`
`182`	`182`	`{`
`183`		`- return GetOrAddAsync(key, addItemFactory, null);`
	`183`	`+ return GetOrAddAsync(key, addItemFactory, DefaultCachePolicy.BuildOptions());`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`public virtual async Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory,`