Cleaned up the code.

Added more information in the README.md

Author: cristeh

README.md

@@ -4,15 +4,15 @@ It makes use of the TTL functionality to get remove the stale cache keys.
 IDistributedCache is a low-level interface used by cache-related consumers, such as Polly. Microsoft also provides a set of extension methods that simplify common workflows.
 
 ## Considerations
-
+ - There is no optimistic locking(or locking of any kind). If this is a big problem, using a different provider(such as Redis with WATCH) might be better for your use case.
+ - Eventual consistency is used.
  - Deleting DynamoDB items with an expired TTL takes up to 48 hours. There is a soft invalidation in the code to check whether the item has expired or not.
  - Sliding expiration is WIP and experimental. It works in such a way that the TTL is refreshed(by the amount of the sliding expiration) when you do a GetCacheKey and the TTL is about to expire in (SlidingExpirationDuration / 2) seconds.
 	Example:
 	Sliding expiration is set to 30 mins. 
 	The TTL is CurrentTime + 14 mins( < SlidingExpirationDuration / 2).
 	Doing a GET will refresh the TTL to CurrentTime + 14 mins + 30 mins.
 	A subsequent GET will not refresh the key until the condition is met again.
- - While methods are thread-safe, data race conditions are possible. It's up to the caller to manage them correctly.
  - Sync methods are disabled by default due to the fact that Amazon's DynamoDb client uses HttpClient internally, which lacks sync methods. There is an override that will enable them, but doing so is not recommended.
  - The library is still **quite raw**. Any pull requests, ideas and feedback are encouraged.
 

src/Albelli.Extensions.Caching.DynamoDb/DynamoDbCache.cs

@@ -63,7 +63,7 @@ public byte[] Get(string key)
             {
                 var slidingExpiry = long.Parse(result.Item[_options.SlidingExpiryTimespanColumnName].N);
                 var currentTime = _systemClock.UtcNow.ToUnixTimeSeconds();
-                if (currentTtl - currentTime <= slidingExpiry / 2.0)
+                if (currentTtl - currentTime <= slidingExpiry / 2)
                 {
                     await RefreshAsync(key, token).ConfigureAwait(false);
                 }
@@ -95,34 +95,8 @@ public async Task SetAsync(string key, byte[] value, DistributedCacheEntryOption
                 options = new DistributedCacheEntryOptions()
                     {AbsoluteExpirationRelativeToNow = _options.DefaultDurationPolicy};
             }
-
-            var table = new Dictionary<string, AttributeValue>()
-            {
-                [_options.KeyColumnName] = new AttributeValue(key),
-                [_options.ValueColumnName] = new AttributeValue() {B = new MemoryStream(value)},
-            };
-            var slidingExpirationTicks = options.SlidingExpiration.HasValue
-                ? Convert.ToInt64(Math.Round(options.SlidingExpiration.Value.TotalSeconds))
-                : (long?) null;
-            var absoluteExpirationTimestamp =
-                GetAbsoluteExpirationUnixTimestamp(options.AbsoluteExpiration, options.AbsoluteExpirationRelativeToNow)
-                    ?.ToUnixTimeSeconds();
-            if (slidingExpirationTicks.HasValue)
-            {
-                table.Add(_options.SlidingExpiryTimespanColumnName,
-                    new AttributeValue() {N = slidingExpirationTicks.Value.ToString()});
-            }
-
-            if (absoluteExpirationTimestamp.HasValue)
-            {
-                table.Add(_options.AbsoluteExpiryUnixTimestampColumnName,
-                    new AttributeValue() {N = absoluteExpirationTimestamp.Value.ToString()});
-            }
-
-            table.Add(_options.TimeToLiveColumnName,
-                new AttributeValue()
-                    {N = GetInitialTtlTimestamp(slidingExpirationTicks, absoluteExpirationTimestamp).ToString()});
-            await _dynamoDb.PutItemAsync(_options.TableName, table, token).ConfigureAwait(false);
+            var dynamoDbCacheEntry = BuildDynamoDbCacheEntry(key, value, options);
+            await _dynamoDb.PutItemAsync(_options.TableName, dynamoDbCacheEntry, token).ConfigureAwait(false);
         }
 
         public void Refresh(string key)
@@ -180,6 +154,37 @@ await _dynamoDb.DeleteItemAsync(_options.TableName,
                     token)
                 .ConfigureAwait(false);
         }
+        
+        private Dictionary<string, AttributeValue> BuildDynamoDbCacheEntry(string key, byte[] value,
+            DistributedCacheEntryOptions options)
+        {
+            var table = new Dictionary<string, AttributeValue>()
+            {
+                [_options.KeyColumnName] = new AttributeValue(key),
+                [_options.ValueColumnName] = new AttributeValue() {B = new MemoryStream(value)},
+            };
+            var slidingExpirationTicks = options.SlidingExpiration.HasValue
+                ? Convert.ToInt64(Math.Round(options.SlidingExpiration.Value.TotalSeconds))
+                : (long?) null;
+            var absoluteExpirationTimestamp =
+                GetAbsoluteExpirationUnixTimestamp(options.AbsoluteExpiration, options.AbsoluteExpirationRelativeToNow);
+            if (slidingExpirationTicks.HasValue)
+            {
+                table.Add(_options.SlidingExpiryTimespanColumnName,
+                    new AttributeValue() {N = slidingExpirationTicks.Value.ToString()});
+            }
+
+            if (absoluteExpirationTimestamp.HasValue)
+            {
+                table.Add(_options.AbsoluteExpiryUnixTimestampColumnName,
+                    new AttributeValue() {N = absoluteExpirationTimestamp.Value.ToString()});
+            }
+
+            table.Add(_options.TimeToLiveColumnName,
+                new AttributeValue()
+                    {N = GetInitialTtlTimestamp(slidingExpirationTicks, absoluteExpirationTimestamp).ToString()});
+            return table;
+        }
 
         private long GetInitialTtlTimestamp(long? slidingExpirationTicks, long? absoluteExpirationTimestamp)
         {
@@ -194,7 +199,7 @@ private long GetInitialTtlTimestamp(long? slidingExpirationTicks, long? absolute
             }
         }
 
-        private DateTimeOffset? GetAbsoluteExpirationUnixTimestamp(DateTimeOffset? absoluteExpiration,
+        private long? GetAbsoluteExpirationUnixTimestamp(DateTimeOffset? absoluteExpiration,
             TimeSpan? relativeToNowAbsoluteExpiration)
         {
             DateTimeOffset? result = null;
@@ -213,7 +218,7 @@ private long GetInitialTtlTimestamp(long? slidingExpirationTicks, long? absolute
                 result = _systemClock.UtcNow.Add(relativeToNowAbsoluteExpiration.Value);
             }
 
-            return result;
+            return result?.ToUnixTimeSeconds();
         }
     }
 }

test/Albelli.Extensions.Caching.Tests.Integration/DynamoDbCacheIntegrationTests.cs

@@ -21,7 +21,7 @@ public class DynamoDbCacheIntegrationTests
         private readonly IDistributedCache _cache;
         public DynamoDbCacheIntegrationTests() => _cache = new DynamoDbCache(_options, _systemClock, _dynamoDb);
 
-        [Fact(Skip = "Local only.")]
+        [Fact(Skip = "Local only")]
         public async Task Should_Successfully_Create_And_Retrieve_Keys()
         {
             var dummyKey =  $"TestKey{Guid.NewGuid():N}";
@@ -31,28 +31,28 @@ public async Task Should_Successfully_Create_And_Retrieve_Keys()
             Assert.Equal(dummyValue, result);
         }
 
-        [Fact(Skip = "Local only.")]        
+        [Fact(Skip = "Local only")]    
         public async Task Should_recalculate_sliding_expiration_properly()
         {
             var dummyKey =  $"TestKey{Guid.NewGuid():N}";
             var dummyValue = "Hi, there!";
             await _cache.SetStringAsync(dummyKey, dummyValue, new DistributedCacheEntryOptions()
             {
                 AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1),
-                SlidingExpiration = TimeSpan.FromSeconds(5)
+                SlidingExpiration = TimeSpan.FromSeconds(10)
             });
             for (var i = 0; i <= 5; i++)
             {
-                await Task.Delay(3000);
+                await Task.Delay(7000);
                 var result = await _cache.GetStringAsync(dummyKey);
                 Assert.Equal(dummyValue, result);
             }
-            await Task.Delay(7000);
+            await Task.Delay(25000);
             var finalResult = await _cache.GetStringAsync(dummyKey);
             Assert.Null(finalResult);
         }
 
-        [Fact(Skip = "Local only.")]
+        [Fact(Skip = "Local only")]
         public async Task Should_expire_after_five_seconds()
         {
             var dummyKey =  $"TestKey{Guid.NewGuid():N}";
@@ -68,7 +68,7 @@ public async Task Should_expire_after_five_seconds()
             Assert.Null(finalResult);
         }
 
-        [Fact(Skip = "Local only.")]
+        [Fact(Skip = "Local only")]
         public async Task Should_delete_the_key_properly()
         {
             var dummyKey =  $"TestKey{Guid.NewGuid():N}";