add tests that verify the KeyTransformer is used properly in Get/Store/Remove operations

Author: John Gonyo

Enyim.Caching.Tests/MemcachedClientTestsBase.cs

@@ -9,17 +9,26 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
+using System.Threading.Tasks;
 
 namespace Enyim.Caching.Tests
 {
     public abstract class MemcachedClientTestsBase
     {
         protected MemcachedClient _client;
 
-        public MemcachedClientTestsBase()
+        public MemcachedClientTestsBase(Action<MemcachedClientOptions> onAddEnyimMemcached = null)
         {
             IServiceCollection services = new ServiceCollection();
-            services.AddEnyimMemcached(options => options.AddServer("memcached", 11211));
+            services.AddEnyimMemcached(options =>
+            {
+                options.AddServer("memcached", 11211);
+                if (onAddEnyimMemcached != null)
+                {
+                    onAddEnyimMemcached(options);
+                }
+            });
+
             services.AddLogging(builder => builder.SetMinimumLevel(LogLevel.Debug).AddConsole());
             IServiceProvider serviceProvider = services.BuildServiceProvider();
             _client = serviceProvider.GetService<IMemcachedClient>() as MemcachedClient;
@@ -63,6 +72,20 @@ protected IStoreOperationResult Store(StoreMode mode = StoreMode.Set, string key
             return _client.ExecuteStore(mode, key, value);
         }
 
+        protected Task<bool> StoreAsync(StoreMode mode = StoreMode.Set, string key = null, object value = null)
+        {
+            if (string.IsNullOrEmpty(key))
+            {
+                key = GetUniqueKey("store");
+            }
+
+            if (value == null)
+            {
+                value = GetRandomString();
+            }
+            return _client.StoreAsync(mode, key, value, TimeSpan.MaxValue);
+        }
+
         protected void StoreAssertPass(IStoreOperationResult result)
         {
             Assert.True(result.Success, "Success was false");
@@ -95,6 +118,15 @@ protected void GetAssertFail(IGetOperationResult result)
             Assert.Null(result.Value);
         }
 
+        protected void GetAssertFail(IGetOperationResult<object> result)
+        {
+            Assert.False(result.Success, "Success was true");
+            Assert.Equal((ulong)0, result.Cas);
+            Assert.True(result.StatusCode > 0, "StatusCode not greater than 0");
+            Assert.False(result.HasValue, "HasValue was true");
+            Assert.Null(result.Value);
+        }
+
         protected void MutateAssertPass(IMutateOperationResult result, ulong expectedValue)
         {
             Assert.True(result.Success, "Success was false");

Enyim.Caching.Tests/MemcachedClientWithKeyTransformerTests.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Enyim.Caching.Configuration;
+using Enyim.Caching.Memcached;
+using Xunit;
+
+namespace Enyim.Caching.Tests
+{
+    public class MemcachedClientWithKeyTransformerTests : MemcachedClientTestsBase
+    {
+        public MemcachedClientWithKeyTransformerTests(Action<MemcachedClientOptions> onAddEnyimMemcached = null)
+            : base(options =>
+                    {
+                        options.KeyTransformer = "Enyim.Caching.Memcached.TigerHashKeyTransformer";
+                        if (onAddEnyimMemcached != null)
+                        {
+                            onAddEnyimMemcached(options);
+                        }
+                    })
+        {
+        }
+
+        [Fact]
+        public void When_Removing_A_Valid_Transformed_Key_Is_Successful()
+        {
+            var key = GetUniqueKey("remove");
+            var storeResult = Store(key: key);
+            StoreAssertPass(storeResult);
+
+            var removeResult = _client.ExecuteRemove(key);
+            Assert.True(removeResult.Success, "Success was false");
+            Assert.True((removeResult.StatusCode ?? 0) == 0, "StatusCode was neither null nor 0");
+
+            var getResult = _client.ExecuteGet(key);
+            GetAssertFail(getResult);
+        }
+
+
+        [Fact]
+        public async Task When_Removing_A_Valid_Transformed_Key_Is_Successful_Async()
+        {
+            var key = GetUniqueKey("remove");
+            var storeResult = await StoreAsync(key: key);
+            Assert.True(storeResult, "Success was false");
+
+            var removeResult = await _client.RemoveAsync(key);
+
+            Assert.True(removeResult, "Success was false");
+
+            var getResult = await _client.GetAsync<object>(key);
+            GetAssertFail(getResult);
+        }
+
+        [Fact]
+        public void When_Getting_Existing_Item_Value_With_Transformed_Key_Is_Not_Null_And_Result_Is_Successful()
+        {
+            var key = GetUniqueKey("get");
+            var value = GetRandomString();
+            var storeResult = Store(key: key, value: value);
+            StoreAssertPass(storeResult);
+
+            var getResult = _client.ExecuteGet(key);
+            GetAssertPass(getResult, value);
+        }
+
+        [Fact]
+        public void When_Storing_Item_With_With_Transformed_Key_And_Valid_Cas_Result_Is_Successful()
+        {
+            var key = GetUniqueKey("cas");
+            var value = GetRandomString();
+            var storeResult = Store(StoreMode.Add, key, value);
+            StoreAssertPass(storeResult);
+
+            var casResult = _client.ExecuteCas(StoreMode.Set, key, value, storeResult.Cas);
+            StoreAssertPass(casResult);
+        }
+    }
+}