double result implementation.

fehmianac · fehmianac · commit bdffd18aa4ae · 2021-08-21T16:18:29.000+03:00
diff --git a/src/MultiCache.StackExchangeRedis/MultiCache.StackExchangeRedis.csproj b/src/MultiCache.StackExchangeRedis/MultiCache.StackExchangeRedis.csproj
@@ -29,6 +29,6 @@
         <PackageReference Include="Microsoft.Extensions.Hosting" Version="5.0.0" />
     </ItemGroup>
     <ItemGroup>
-      <PackageReference Include="MultiCache" Version="1.0.1" />
+      <PackageReference Include="MultiCache" Version="1.0.2" />
     </ItemGroup>
 </Project>
diff --git a/src/MultiCache.StackExchangeRedis/Redis/RedisMultiCacheManager.cs b/src/MultiCache.StackExchangeRedis/Redis/RedisMultiCacheManager.cs
@@ -18,20 +18,20 @@ public RedisMultiCacheManager(IRedisClient redisClient, IMemoryClient memoryCach
             _memoryCache = memoryCache;
         }
 
-        public async Task<T> GetAsync<T>(string key, CancellationToken cancellationToken = default)
+        public async Task<(T, bool)> GetAsync<T>(string key, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             var isExistsInMemory = _memoryCache.TryGetValue(key, out T response);
             if (isExistsInMemory)
             {
-                return response;
+                return (response, true);
             }
 
             var (value, expiry) = await _redisClient.GetWithExpiryAsync(key, cancellationToken).ConfigureAwait(false);
             if (value == null)
             {
-                return default;
+                return (default, false);
             }
 
             response = JsonSerializer.Deserialize<T>(value);
@@ -44,7 +44,7 @@ public async Task<T> GetAsync<T>(string key, CancellationToken cancellationToken
                 _memoryCache.Set(key, response);
             }
 
-            return response;
+            return (response, true);
         }
 
         public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null, CancellationToken cancellationToken = default)
@@ -63,30 +63,30 @@ public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null, Canc
             await _redisClient.SetAsync(key, JsonSerializer.SerializeToUtf8Bytes(value), expiry, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiry = null, CancellationToken cancellationToken = default)
+        public async Task<(T, bool)> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiry = null, CancellationToken cancellationToken = default)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            var cacheResult = await GetAsync<T>(key, cancellationToken);
+            var (cacheResult, fromCache) = await GetAsync<T>(key, cancellationToken);
             if (cacheResult != null)
-                return cacheResult;
+                return (cacheResult, fromCache);
 
             var result = await factory();
 
             if (result == null)
             {
-                return default(T);
+                return (default(T), false);
             }
 
             await SetAsync(key, result, expiry, cancellationToken);
-            return result;
+            return (result, true);
         }
 
         public async Task RemoveAsync(string key, CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
-            
+
             await _redisClient.RemoveAsync(key, cancellationToken);
         }
     }
-}
+}
diff --git a/tests/MultiCache.StackExchangeRedis.Tests/MultiCacheManagerTests/GetAsyncTests.cs b/tests/MultiCache.StackExchangeRedis.Tests/MultiCacheManagerTests/GetAsyncTests.cs
@@ -44,9 +44,10 @@ public async Task Should_Return_From_Memory_If_Cache_Exist_In_Memory(string cach
             _memoryClientMock.Setup(q => q.TryGetValue(cacheKey, out response)).Returns(true);
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetAsync<string>(cacheKey);
+            var (cachedResult, fromCache) = await multiCacheManager.GetAsync<string>(cacheKey);
 
             Assert.Equal(response, cachedResult);
+            Assert.True(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
         }
 
@@ -58,10 +59,10 @@ public async Task Should_Return_Empty_If_Cache_Doesnt_Exist_In_Memory_And_Redis(
             _redisClientMock.Setup(q => q.GetWithExpiryAsync(cacheKey, default)).ReturnsAsync(() => (null, TimeSpan.Zero));
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetAsync<string>(cacheKey);
+            var (cachedResult, fromCache) = await multiCacheManager.GetAsync<string>(cacheKey);
 
             Assert.Equal(default, cachedResult);
-
+            Assert.False(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
             _redisClientMock.Verify(q => q.GetWithExpiryAsync(cacheKey, It.IsAny<CancellationToken>()), Times.Once);
         }
@@ -77,9 +78,10 @@ public async Task Should_Return_From_Redis_And_Set_Memory_With_TTL_When_Cache_Ex
             _redisClientMock.Setup(q => q.GetWithExpiryAsync(cacheKey, default)).ReturnsAsync(() => (JsonSerializer.SerializeToUtf8Bytes(response), redisTtl));
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetAsync<string>(cacheKey);
+            var (cachedResult, fromCache) = await multiCacheManager.GetAsync<string>(cacheKey);
 
             Assert.Equal(response, cachedResult);
+            Assert.True(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
             _memoryClientMock.Verify(q => q.Set(cacheKey, response, redisTtl), Times.Once);
             _redisClientMock.Verify(q => q.GetWithExpiryAsync(cacheKey, It.IsAny<CancellationToken>()), Times.Once);
@@ -95,12 +97,13 @@ public async Task Should_Return_From_Redis_And_Set_Memory_Without_TTL_When_Cache
             _redisClientMock.Setup(q => q.GetWithExpiryAsync(cacheKey, default)).ReturnsAsync(() => (JsonSerializer.SerializeToUtf8Bytes(response), null));
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetAsync<string>(cacheKey);
+            var (cachedResult, fromCache) = await multiCacheManager.GetAsync<string>(cacheKey);
 
             Assert.Equal(response, cachedResult);
+            Assert.True(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
             _memoryClientMock.Verify(q => q.Set(cacheKey, response), Times.Once);
             _redisClientMock.Verify(q => q.GetWithExpiryAsync(cacheKey, It.IsAny<CancellationToken>()), Times.Once);
         }
     }
-}
+}
diff --git a/tests/MultiCache.StackExchangeRedis.Tests/MultiCacheManagerTests/GetOrCreateAsyncTests.cs b/tests/MultiCache.StackExchangeRedis.Tests/MultiCacheManagerTests/GetOrCreateAsyncTests.cs
@@ -43,9 +43,9 @@ public async Task Should_Return_Data_When_Cache_Exist_In_Cache(string cacheKey)
             _memoryClientMock.Setup(q => q.TryGetValue(cacheKey, out response)).Returns(true);
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetOrCreateAsync(cacheKey, async () => await Task.FromResult(Guid.NewGuid().ToString()), TimeSpan.Zero);
-
+            var (cachedResult,fromCache) = await multiCacheManager.GetOrCreateAsync(cacheKey, async () => await Task.FromResult(Guid.NewGuid().ToString()), TimeSpan.Zero);
             Assert.Equal(response, cachedResult);
+            Assert.True(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
         }
 
@@ -62,9 +62,10 @@ static Task<string> Func()
             }
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetOrCreateAsync(cacheKey, Func, TimeSpan.Zero);
+            var (cachedResult,fromCache) = await multiCacheManager.GetOrCreateAsync(cacheKey, Func, TimeSpan.Zero);
 
             Assert.Null(cachedResult);
+            Assert.False(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
             _redisClientMock.Verify(q => q.GetWithExpiryAsync(cacheKey, It.IsAny<CancellationToken>()), Times.Once);
         }
@@ -88,9 +89,10 @@ Task<string> Func()
             }
 
             var multiCacheManager = _autoMock.Create<RedisMultiCacheManager>();
-            var cachedResult = await multiCacheManager.GetOrCreateAsync(cacheKey, Func, timeSpan);
+            var (cachedResult,fromCache)  = await multiCacheManager.GetOrCreateAsync(cacheKey, Func, timeSpan);
 
             Assert.Equal(response, cachedResult);
+            Assert.True(fromCache);
             _memoryClientMock.Verify(q => q.TryGetValue(cacheKey, out response), Times.Once);
             _memoryClientMock.Verify(q => q.Set(cacheKey, response, timeSpan), Times.Once);
             _redisClientMock.Verify(q => q.GetWithExpiryAsync(cacheKey, It.IsAny<CancellationToken>()), Times.Once);

Original file line number	Diff line number	Diff line change
`@@ -18,20 +18,20 @@ public RedisMultiCacheManager(IRedisClient redisClient, IMemoryClient memoryCach`
`18`	`18`	`_memoryCache = memoryCache;`
`19`	`19`	`}`
`20`	`20`
`21`		`- public async Task<T> GetAsync<T>(string key, CancellationToken cancellationToken = default)`
	`21`	`+ public async Task<(T, bool)> GetAsync<T>(string key, CancellationToken cancellationToken = default)`
`22`	`22`	`{`
`23`	`23`	`cancellationToken.ThrowIfCancellationRequested();`
`24`	`24`
`25`	`25`	`var isExistsInMemory = _memoryCache.TryGetValue(key, out T response);`
`26`	`26`	`if (isExistsInMemory)`
`27`	`27`	`{`
`28`		`- return response;`
	`28`	`+ return (response, true);`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`var (value, expiry) = await _redisClient.GetWithExpiryAsync(key, cancellationToken).ConfigureAwait(false);`
`32`	`32`	`if (value == null)`
`33`	`33`	`{`
`34`		`- return default;`
	`34`	`+ return (default, false);`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`response = JsonSerializer.Deserialize<T>(value);`
`@@ -44,7 +44,7 @@ public async Task<T> GetAsync<T>(string key, CancellationToken cancellationToken`
`44`	`44`	`_memoryCache.Set(key, response);`
`45`	`45`	`}`
`46`	`46`
`47`		`- return response;`
	`47`	`+ return (response, true);`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null, CancellationToken cancellationToken = default)`
`@@ -63,30 +63,30 @@ public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null, Canc`
`63`	`63`	`await _redisClient.SetAsync(key, JsonSerializer.SerializeToUtf8Bytes(value), expiry, cancellationToken).ConfigureAwait(false);`
`64`	`64`	`}`
`65`	`65`
`66`		`- public async Task<T> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiry = null, CancellationToken cancellationToken = default)`
	`66`	`+ public async Task<(T, bool)> GetOrCreateAsync<T>(string key, Func<Task<T>> factory, TimeSpan? expiry = null, CancellationToken cancellationToken = default)`
`67`	`67`	`{`
`68`	`68`	`cancellationToken.ThrowIfCancellationRequested();`
`69`	`69`
`70`		`- var cacheResult = await GetAsync<T>(key, cancellationToken);`
	`70`	`+ var (cacheResult, fromCache) = await GetAsync<T>(key, cancellationToken);`
`71`	`71`	`if (cacheResult != null)`
`72`		`- return cacheResult;`
	`72`	`+ return (cacheResult, fromCache);`
`73`	`73`
`74`	`74`	`var result = await factory();`
`75`	`75`
`76`	`76`	`if (result == null)`
`77`	`77`	`{`
`78`		`- return default(T);`
	`78`	`+ return (default(T), false);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`await SetAsync(key, result, expiry, cancellationToken);`
`82`		`- return result;`
	`82`	`+ return (result, true);`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`public async Task RemoveAsync(string key, CancellationToken cancellationToken)`
`86`	`86`	`{`
`87`	`87`	`cancellationToken.ThrowIfCancellationRequested();`
`88`		`-`
	`88`	`+`
`89`	`89`	`await _redisClient.RemoveAsync(key, cancellationToken);`
`90`	`90`	`}`
`91`	`91`	`}`
`92`		`-}`
	`92`	`+}`