Cache interface support for factory arg (#351)

bitfaster · web-flow · commit 5df1ff390adb · 2023-04-29T12:36:34.000-07:00
* interface support

* functional default

* to base

* scopedasync test

* cache default

* tests

* cleanup
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedAsyncCacheTests.cs
@@ -46,21 +46,6 @@ public async Task WhenKeyDoesNotExistGetOrAddAsyncAddsValue()
             this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
         }
 
-        [Fact]
-        public async Task WhenKeyDoesNotExistGetOrAddArgAddsValueWithArg()
-        {
-            // TODO: move to base when interface supports factory arg
-            var c = this.cache as AtomicFactoryScopedAsyncCache<int, Disposable>;
-
-            await c.ScopedGetOrAddAsync(
-                1,
-                (k, a) => Task.FromResult(new Scoped<Disposable>(new Disposable(a))),
-                2);
-
-            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
-            lifetime.Value.State.Should().Be(2);
-        }
-
         [Fact]
         public async Task GetOrAddAsyncDisposedScopeThrows()
         {
diff --git a/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedCacheTests.cs b/BitFaster.Caching.UnitTests/Atomic/AtomicFactoryScopedCacheTests.cs
@@ -46,21 +46,6 @@ public void WhenKeyDoesNotExistGetOrAddAddsValue()
             this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
         }
 
-        [Fact]
-        public void WhenKeyDoesNotExistGetOrAddArgAddsValueWithArg()
-        {
-            // TODO: move to base when interface supports factory arg
-            var c = this.cache as AtomicFactoryScopedCache<int, Disposable>;
-
-            c.ScopedGetOrAdd(
-                1, 
-                (k, a) => new Scoped<Disposable>(new Disposable(a)), 
-                2);
-
-            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
-            lifetime.Value.State.Should().Be(2);
-        }
-
         [Fact]
         public void GetOrAddDisposedScopeThrows()
         {
diff --git a/BitFaster.Caching.UnitTests/CacheTests.cs b/BitFaster.Caching.UnitTests/CacheTests.cs
@@ -0,0 +1,96 @@
+﻿
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Moq;
+using Xunit;
+
+namespace BitFaster.Caching.UnitTests
+{
+    // Tests for interface default implementations.
+    public class CacheTests
+    {
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenCacheInterfaceDefaultGetOrAddFallback()
+        {
+            var cache = new Mock<ICache<int, int>>();
+            cache.CallBase = true;
+
+            Func<int, Func<int, int>, int> evaluate = (k, f) => f(k);
+            cache.Setup(c => c.GetOrAdd(It.IsAny<int>(), It.IsAny<Func<int, int>>())).Returns(evaluate);
+
+            cache.Object.GetOrAdd(
+                1, 
+                (k, a) => k + a, 
+                2).Should().Be(3);
+        }
+
+        [Fact]
+        public async Task WhenAsyncCacheInterfaceDefaultGetOrAddFallback()
+        {
+            var cache = new Mock<IAsyncCache<int, int>>();
+            cache.CallBase = true;
+
+            Func<int, Func<int, Task<int>>, ValueTask<int>> evaluate = (k, f) => new ValueTask<int>(f(k));
+            cache.Setup(c => c.GetOrAddAsync(It.IsAny<int>(), It.IsAny<Func<int, Task<int>>>())).Returns(evaluate);
+
+             var r = await cache.Object.GetOrAddAsync(
+                1,
+                (k, a) => Task.FromResult(k + a),
+                2);
+            
+            r.Should().Be(3);
+        }
+
+        [Fact]
+        public void WhenScopedCacheInterfaceDefaultGetOrAddFallback()
+        {
+            var cache = new Mock<IScopedCache<int, Disposable>>();
+            cache.CallBase = true;
+
+            Func<int, Func<int, Scoped<Disposable>>, Lifetime<Disposable>> evaluate = (k, f) =>
+                {
+                    var scope = f(k);
+                    scope.TryCreateLifetime(out var lifetime).Should().BeTrue();
+                    return lifetime;
+                };
+
+            cache.Setup(c => c.ScopedGetOrAdd(It.IsAny<int>(), It.IsAny<Func<int, Scoped<Disposable>>>())).Returns(evaluate);
+
+            var l = cache.Object.ScopedGetOrAdd(
+                1,
+                (k, a) => new Scoped<Disposable>(new Disposable(k + a)),
+                2);
+
+            l.Value.State.Should().Be(3);
+        }
+
+        [Fact]
+        public async Task WhenScopedAsyncCacheInterfaceDefaultGetOrAddFallback()
+        {
+            var cache = new Mock<IScopedAsyncCache<int, Disposable>>();
+            cache.CallBase = true;
+
+            Func<int, Func<int, Task<Scoped<Disposable>>>, ValueTask<Lifetime<Disposable>>> evaluate = async (k, f) =>
+            {
+                var scope = await f(k);
+                scope.TryCreateLifetime(out var lifetime).Should().BeTrue();
+                return lifetime;
+            };
+
+            cache
+                .Setup(c => c.ScopedGetOrAddAsync(It.IsAny<int>(), It.IsAny<Func<int, Task<Scoped<Disposable>>>>()))
+                .Returns(evaluate);
+
+            var lifetime = await cache.Object.ScopedGetOrAddAsync(
+               1,
+               (k, a) => Task.FromResult(new Scoped<Disposable>(new Disposable(k + a))),
+               2);
+
+            lifetime.Value.State.Should().Be(3);
+        }
+#endif
+    }
+}
diff --git a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTestBase.cs
@@ -2,7 +2,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Xunit;
@@ -83,6 +82,20 @@ public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
             lifetime.Value.Should().Be(d);
         }
 
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public async Task WhenKeyDoesNotExistGetOrAddArgAddsValueWithArg()
+        {
+            await this.cache.ScopedGetOrAddAsync(
+                1,
+                (k, a) => Task.FromResult(new Scoped<Disposable>(new Disposable(a))),
+                2);
+
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
+            lifetime.Value.State.Should().Be(2);
+        }
+#endif
         [Fact]
         public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
         {
diff --git a/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs b/BitFaster.Caching.UnitTests/ScopedAsyncCacheTests.cs
@@ -51,5 +51,19 @@ public async Task GetOrAddAsyncDisposedScopeThrows()
 
             await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
         }
+
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public async Task GetOrAddAsyncArgDisposedScopeThrows()
+        {
+            var scope = new Scoped<Disposable>(new Disposable());
+            scope.Dispose();
+
+            Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, (k, a) => Task.FromResult(scope), 2); };
+
+            await getOrAdd.Should().ThrowAsync<InvalidOperationException>();
+        }
+#endif
     }
 }
diff --git a/BitFaster.Caching.UnitTests/ScopedCacheTestBase.cs b/BitFaster.Caching.UnitTests/ScopedCacheTestBase.cs
@@ -81,6 +81,21 @@ public void WhenKeyDoesNotExistAddOrUpdateAddsNewItem()
             lifetime.Value.Should().Be(d);
         }
 
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        [Fact]
+        public void WhenKeyDoesNotExistGetOrAddArgAddsValueWithArg()
+        {
+            this.cache.ScopedGetOrAdd(
+                1,
+                (k, a) => new Scoped<Disposable>(new Disposable(a)),
+                2);
+
+            this.cache.ScopedTryGet(1, out var lifetime).Should().BeTrue();
+            lifetime.Value.State.Should().Be(2);
+        }
+#endif
+
         [Fact]
         public void WhenKeyExistsAddOrUpdateUpdatesExistingItem()
         {
diff --git a/BitFaster.Caching/IAsyncCache.cs b/BitFaster.Caching/IAsyncCache.cs
@@ -1,7 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching
@@ -55,6 +53,20 @@ public interface IAsyncCache<K, V> : IEnumerable<KeyValuePair<K, V>>
         /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
         ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory);
 
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>A task that represents the asynchronous GetOrAdd operation.</returns>
+        ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valueFactory, TArg factoryArgument) => this.GetOrAddAsync(key, k => valueFactory(k, factoryArgument)); 
+#endif
+
         /// <summary>
         /// Attempts to remove the value that has the specified key.
         /// </summary>
diff --git a/BitFaster.Caching/ICache.cs b/BitFaster.Caching/ICache.cs
@@ -1,8 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching
 {
@@ -56,6 +53,21 @@ public interface ICache<K, V> : IEnumerable<KeyValuePair<K, V>>
         /// in the cache, or the new value if the key was not in the cache.</returns>
         V GetOrAdd(K key, Func<K, V> valueFactory);
 
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/value pair to the cache if the key does not already exist. Returns the new value, or the 
+        /// existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a value for the key.</param>
+        /// <param name="factoryArgument">An argument value to pass into valueFactory.</param>
+        /// <returns>The value for the key. This will be either the existing value for the key if the key is already 
+        /// in the cache, or the new value if the key was not in the cache.</returns>
+        V GetOrAdd<TArg>(K key, Func<K, TArg, V> valueFactory, TArg factoryArgument) => this.GetOrAdd(key, k => valueFactory(k, factoryArgument));
+#endif
+
         /// <summary>
         /// Attempts to remove the value that has the specified key.
         /// </summary>
diff --git a/BitFaster.Caching/IScopedAsyncCache.cs b/BitFaster.Caching/IScopedAsyncCache.cs
@@ -1,7 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching
@@ -60,6 +58,20 @@ public interface IScopedAsyncCache<K, V> : IEnumerable<KeyValuePair<K, Scoped<V>
         /// <returns>A task that represents the asynchronous ScopedGetOrAdd operation.</returns>
         ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scoped<V>>> valueFactory);
 
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/scoped value pair to the cache if the key does not already exist. Returns a lifetime for either 
+        /// the new value, or the existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a scoped value for the key.</param>
+        /// <param name="factoryArgument"></param>
+        /// <returns>A task that represents the asynchronous ScopedGetOrAdd operation.</returns>
+        ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TArg>(K key, Func<K, TArg, Task<Scoped<V>>> valueFactory, TArg factoryArgument) => this.ScopedGetOrAddAsync(key, (k) => valueFactory(k, factoryArgument));
+#endif
+
         /// <summary>
         /// Attempts to remove the value that has the specified key.
         /// </summary>
diff --git a/BitFaster.Caching/IScopedCache.cs b/BitFaster.Caching/IScopedCache.cs
@@ -1,8 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BitFaster.Caching
 {
@@ -62,6 +59,22 @@ public interface IScopedCache<K, V> : IEnumerable<KeyValuePair<K, Scoped<V>>> wh
         /// the cache.</returns>
         Lifetime<V> ScopedGetOrAdd(K key, Func<K, Scoped<V>> valueFactory);
 
+        // backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/scoped value pair to the cache if the key does not already exist. Returns a lifetime for either 
+        /// the new value, or the existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to generate a scoped value for the key.</param>
+        /// <param name="factoryArgument"></param>
+        /// <returns>The lifetime for the value associated with the key. The lifetime will be either reference the 
+        /// existing value for the key if the key is already in the cache, or the new value if the key was not in 
+        /// the cache.</returns>
+        Lifetime<V> ScopedGetOrAdd<TArg>(K key, Func<K, TArg, Scoped<V>> valueFactory, TArg factoryArgument) => this.ScopedGetOrAdd(key, k => valueFactory(k, factoryArgument));
+#endif
+
         /// <summary>
         /// Attempts to remove the value that has the specified key.
         /// </summary>
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -85,6 +85,40 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scop
             }
         }
 
+// backcompat: remove conditional compile
+#if NETCOREAPP3_0_OR_GREATER
+        /// <summary>
+        /// Adds a key/scoped value pair to the cache if the key does not already exist. Returns a lifetime for either 
+        /// the new value, or the existing value if the key already exists.
+        /// </summary>
+        /// <typeparam name="TArg">The type of an argument to pass into valueFactory.</typeparam>
+        /// <param name="key">The key of the element to add.</param>
+        /// <param name="valueFactory">The factory function used to asynchronously generate a scoped value for the key.</param>
+        /// <param name="factoryArgument"></param>
+        /// <returns>A task that represents the asynchronous ScopedGetOrAdd operation.</returns>
+        public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TArg>(K key, Func<K, TArg, Task<Scoped<V>>> valueFactory, TArg factoryArgument)
+        {
+            int c = 0;
+            var spinwait = new SpinWait();
+            while (true)
+            {
+                var scope = await cache.GetOrAddAsync(key, valueFactory, factoryArgument);
+
+                if (scope.TryCreateLifetime(out var lifetime))
+                {
+                    return lifetime;
+                }
+
+                spinwait.SpinOnce();
+
+                if (c++ > ScopedCacheDefaults.MaxRetry)
+                {
+                    Throw.ScopedRetryFailure();
+                }
+            }
+        }
+#endif
+
         ///<inheritdoc/>
         public bool ScopedTryGet(K key, out Lifetime<V> lifetime)
         {
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs

Original file line number	Diff line number	Diff line change
`@@ -51,5 +51,19 @@ public async Task GetOrAddAsyncDisposedScopeThrows()`
`51`	`51`
`52`	`52`	`await getOrAdd.Should().ThrowAsync<InvalidOperationException>();`
`53`	`53`	`}`
	`54`	`+`
	`55`	`+// backcompat: remove conditional compile`
	`56`	`+#if NETCOREAPP3_0_OR_GREATER`
	`57`	`+ [Fact]`
	`58`	`+ public async Task GetOrAddAsyncArgDisposedScopeThrows()`
	`59`	`+ {`
	`60`	`+ var scope = new Scoped<Disposable>(new Disposable());`
	`61`	`+ scope.Dispose();`
	`62`	`+`
	`63`	`+ Func<Task> getOrAdd = async () => { await this.cache.ScopedGetOrAddAsync(1, (k, a) => Task.FromResult(scope), 2); };`
	`64`	`+`
	`65`	`+ await getOrAdd.Should().ThrowAsync<InvalidOperationException>();`
	`66`	`+ }`
	`67`	`+#endif`
`54`	`68`	`}`
`55`	`69`	`}`