zzzprojects#769 - Rename Config ReturnExpiredItems; Refactor Tests

Author: Travis Whidden

src/System.Linq.Dynamic.Core/Util/Cache/CacheConfig.cs

@@ -32,5 +32,5 @@ public class CacheConfig
     /// when cached items are deterministic, ensuring consistent results even from expired entries.
     /// Default true;
     /// </summary>
-    public bool PermitExpiredReturns { get; set; } = true;
+    public bool ReturnExpiredItems { get; set; } = true;
 }

src/System.Linq.Dynamic.Core/Util/Cache/SlidingCache.cs

@@ -12,7 +12,7 @@ internal class SlidingCache<TKey, TValue> where TKey : notnull where TValue : no
     private readonly IDateTimeUtils _dateTimeProvider;
     private readonly Action _deleteExpiredCachedItemsDelegate;
     private readonly long? _minCacheItemsBeforeCleanup;
-    private readonly bool _permitExpiredReturns;
+    private readonly bool _returnExpiredItems;
     private DateTime _lastCleanupTime;
     private int _cleanupLocked = 0;
 
@@ -29,19 +29,19 @@ internal class SlidingCache<TKey, TValue> where TKey : notnull where TValue : no
     ///     Provides the Time for the Caching object. Default will be created if not supplied. Used
     ///     for Testing classes
     /// </param>
-    /// <param name="permitExpiredReturns">If a request for an item happens to be expired, but is still
+    /// <param name="returnExpiredItems">If a request for an item happens to be expired, but is still
     /// in known, don't expire it and return it instead.</param>
     public SlidingCache(
         TimeSpan timeToLive,
         TimeSpan? cleanupFrequency = null,
         long? minCacheItemsBeforeCleanup = null,
         IDateTimeUtils? dateTimeProvider = null,
-        bool permitExpiredReturns = false)
+        bool returnExpiredItems = false)
     {
         _cache = new ConcurrentDictionary<TKey, CacheEntry<TValue>>();
         TimeToLive = timeToLive;
         _minCacheItemsBeforeCleanup = minCacheItemsBeforeCleanup;
-        _permitExpiredReturns = permitExpiredReturns;
+        _returnExpiredItems = returnExpiredItems;
         _cleanupFrequency = cleanupFrequency ?? SlidingCacheConstants.DefaultCleanupFrequency;
         _deleteExpiredCachedItemsDelegate = Cleanup;
         _dateTimeProvider = dateTimeProvider ?? new DateTimeUtils();
@@ -65,7 +65,7 @@ public SlidingCache(CacheConfig cacheConfig, IDateTimeUtils? dateTimeProvider =
         TimeToLive = cacheConfig.TimeToLive;
         _minCacheItemsBeforeCleanup = cacheConfig.MinItemsTrigger;
         _cleanupFrequency = cacheConfig.CleanupFrequency;
-        _permitExpiredReturns = cacheConfig.PermitExpiredReturns;
+        _returnExpiredItems = cacheConfig.ReturnExpiredItems;
         _deleteExpiredCachedItemsDelegate = Cleanup;
         _dateTimeProvider = dateTimeProvider ?? new DateTimeUtils();
         // To prevent a scan on first call, set the last Cleanup to the current Provider time
@@ -114,7 +114,7 @@ public bool TryGetValue(TKey key, [NotNullWhen(true)] out TValue? value)
             {
                 // Permit expired returns will return the object even if was expired
                 // this will prevent the need to re-create the object for the caller
-                if (_permitExpiredReturns || _dateTimeProvider.UtcNow <= valueAndExpiration.ExpirationTime)
+                if (_returnExpiredItems || _dateTimeProvider.UtcNow <= valueAndExpiration.ExpirationTime)
                 {
                     value = valueAndExpiration.Value;
                     var newExpire = _dateTimeProvider.UtcNow.Add(TimeToLive);

test/System.Linq.Dynamic.Core.Tests/Util/Cache/SlidingCacheTests.cs

@@ -48,6 +48,7 @@ public void SlidingCache_TestExpire()
         var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
         dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
 
+        // Arrange
         var cache = new SlidingCache<int, string>(TimeSpan.FromMinutes(10),
             dateTimeProvider: dateTimeUtilsMock.Object);
 
@@ -64,24 +65,24 @@ public void SlidingCache_TestExpire()
     }
 
     [Fact]
-    public void SlidingCache_TestExpiredReturn()
+    public void SlidingCache_TestReturnExpiredItems()
     {
         var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
         dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
 
+        // Arrange
         var cache = new SlidingCache<int, string>(TimeSpan.FromMinutes(10),
-            dateTimeProvider: dateTimeUtilsMock.Object, permitExpiredReturns: true);
+            dateTimeProvider: dateTimeUtilsMock.Object, returnExpiredItems: true);
 
         // Act
         cache.AddOrUpdate(1, "one");
 
+        // move the time forward
         var newDateTime = dateTimeUtilsMock.Object.UtcNow.AddMinutes(11);
         dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(newDateTime);
 
-        if (!cache.TryGetValue(1, out var value))
-        {
-            Assert.True(false, $"Expected to not find the value, but found {value}");
-        }
+        // Ensure the expired item is returned from the cache
+        cache.TryGetValue(1, out _).Should().BeTrue($"Expected to return expired item");
     }
 
     [Fact]