Tests: eliminate a lot of key collisions

Turns out @mgravell really really liked "foo" and "hashset" years ago =P

StackExchange.Redis.Tests/Booksleeve/BookSleeveTestBase.cs

 using StackExchange.Redis.Tests.Helpers;
 using System;
 using System.Diagnostics;
+using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Xunit.Abstractions;
 
@@ -25,7 +26,15 @@ static BookSleeveTestBase()
             };
         }
 
-        public static string CreateUniqueName() => Guid.NewGuid().ToString("N");
+        protected static string Me([CallerMemberName] string caller = null) =>
+#if NET462
+            "net462-" + caller;
+#elif NETCOREAPP2_0
+            "netcoreapp2.0-" + caller;
+#else
+            "unknown-" + caller;
+#endif
+
         internal static IServer GetServer(ConnectionMultiplexer conn) => conn.GetServer(conn.GetEndPoints()[0]);
 
         internal static ConnectionMultiplexer GetRemoteConnection(bool open = true, bool allowAdmin = false, bool waitForOpen = false, int syncTimeout = 5000, int ioTimeout = 5000)

StackExchange.Redis.Tests/Booksleeve/Constraints.cs

@@ -16,7 +16,7 @@ public void ValueEquals()
             Assert.True(x.Equals(y), "equals");
             Assert.True(x == y, "operator");
         }
-        static RedisKey Me([CallerMemberName] string caller = null) => caller;
+
         [Fact]
         public void TestManualIncr()
         {

StackExchange.Redis.Tests/Booksleeve/Issues/SO11766033.cs

@@ -15,7 +15,7 @@ public void TestNullString()
             {
                 var redis = muxer.GetDatabase(db);
                 const string expectedTestValue = null;
-                var uid = CreateUniqueName();
+                var uid = Me();
                 redis.StringSetAsync(uid, "abc");
                 redis.StringSetAsync(uid, expectedTestValue);
                 string testValue = redis.StringGet(uid);
@@ -31,7 +31,7 @@ public void TestEmptyString()
             {
                 var redis = muxer.GetDatabase(db);
                 const string expectedTestValue = "";
-                var uid = CreateUniqueName();
+                var uid = Me();
 
                 redis.StringSetAsync(uid, expectedTestValue);
                 string testValue = redis.StringGet(uid);

StackExchange.Redis.Tests/Booksleeve/PubSub.cs

@@ -19,7 +19,7 @@ public void TestPublishWithNoSubscribers()
             using (var muxer = GetUnsecuredConnection())
             {
                 var conn = muxer.GetSubscriber();
-                Assert.Equal(0, conn.Publish("channel", "message"));
+                Assert.Equal(0, conn.Publish(Me() + "channel", "message"));
             }
         }
 
@@ -29,7 +29,7 @@ public void TestMassivePublishWithWithoutFlush_Local()
             using (var muxer = GetUnsecuredConnection(waitForOpen: true))
             {
                 var conn = muxer.GetSubscriber();
-                TestMassivePublish(conn, "local");
+                TestMassivePublish(conn, Me(), "local");
             }
         }
 
@@ -39,11 +39,11 @@ public void TestMassivePublishWithWithoutFlush_Remote()
             using (var muxer = GetRemoteConnection(waitForOpen: true))
             {
                 var conn = muxer.GetSubscriber();
-                TestMassivePublish(conn, "remote");
+                TestMassivePublish(conn, Me(), "remote");
             }
         }
 
-        private void TestMassivePublish(ISubscriber conn, string caption)
+        private void TestMassivePublish(ISubscriber conn, string channel, string caption)
         {
             const int loop = 100000;
 
@@ -55,7 +55,7 @@ private void TestMassivePublish(ISubscriber conn, string caption)
             var withFAF = Stopwatch.StartNew();
             for (int i = 0; i < loop; i++)
             {
-                conn.Publish("foo", "bar", CommandFlags.FireAndForget);
+                conn.Publish(channel, "bar", CommandFlags.FireAndForget);
             }
             withFAF.Stop();
 
@@ -65,7 +65,7 @@ private void TestMassivePublish(ISubscriber conn, string caption)
             var withAsync = Stopwatch.StartNew();
             for (int i = 0; i < loop; i++)
             {
-                tasks[i] = conn.PublishAsync("foo", "bar");
+                tasks[i] = conn.PublishAsync(channel, "bar");
             }
             conn.WaitAll(tasks);
             withAsync.Stop();
@@ -127,7 +127,7 @@ public async Task PubSubOrder()
         [Fact]
         public void TestPublishWithSubscribers()
         {
-            var channel = "channel" + Guid.NewGuid();
+            var channel = Me();
             using (var muxerA = GetUnsecuredConnection())
             using (var muxerB = GetUnsecuredConnection())
             using (var conn = GetUnsecuredConnection())
@@ -148,7 +148,7 @@ public void TestPublishWithSubscribers()
         [Fact]
         public void TestMultipleSubscribersGetMessage()
         {
-            var channel = "channel" + Guid.NewGuid();
+            var channel = Me();
             using (var muxerA = GetUnsecuredConnection())
             using (var muxerB = GetUnsecuredConnection())
             using (var conn = GetUnsecuredConnection())
@@ -184,17 +184,18 @@ public void Issue38()
             {
                 var sub = pub.GetSubscriber();
                 int count = 0;
+                var prefix = Me();
                 void handler(RedisChannel channel, RedisValue payload) => Interlocked.Increment(ref count);
-                var a0 = sub.SubscribeAsync("foo", handler);
-                var a1 = sub.SubscribeAsync("bar", handler);
-                var b0 = sub.SubscribeAsync("f*o", handler);
-                var b1 = sub.SubscribeAsync("b*r", handler);
+                var a0 = sub.SubscribeAsync(prefix + "foo", handler);
+                var a1 = sub.SubscribeAsync(prefix + "bar", handler);
+                var b0 = sub.SubscribeAsync(prefix + "f*o", handler);
+                var b1 = sub.SubscribeAsync(prefix + "b*r", handler);
                 sub.WaitAll(a0, a1, b0, b1);
 
-                var c = sub.PublishAsync("foo", "foo");
-                var d = sub.PublishAsync("f@o", "f@o");
-                var e = sub.PublishAsync("bar", "bar");
-                var f = sub.PublishAsync("b@r", "b@r");
+                var c = sub.PublishAsync(prefix + "foo", "foo");
+                var d = sub.PublishAsync(prefix + "f@o", "f@o");
+                var e = sub.PublishAsync(prefix + "bar", "bar");
+                var f = sub.PublishAsync(prefix + "b@r", "b@r");
 
                 pub.WaitAll(c, d, e, f);
                 long total = c.Result + d.Result + e.Result + f.Result;
@@ -222,19 +223,20 @@ public void TestPartialSubscriberGetMessage()
                 var listenA = muxerA.GetSubscriber();
                 var listenB = muxerB.GetSubscriber();
                 var pub = conn.GetSubscriber();
-                var tA = listenA.SubscribeAsync("channel", (s, msg) => { if (s == "channel" && msg == "message") Interlocked.Increment(ref gotA); });
-                var tB = listenB.SubscribeAsync("chann*", (s, msg) => { if (s == "channel" && msg == "message") Interlocked.Increment(ref gotB); });
+                var prefix = Me();
+                var tA = listenA.SubscribeAsync(prefix + "channel", (s, msg) => { if (s == prefix + "channel" && msg == "message") Interlocked.Increment(ref gotA); });
+                var tB = listenB.SubscribeAsync(prefix + "chann*", (s, msg) => { if (s == prefix + "channel" && msg == "message") Interlocked.Increment(ref gotB); });
                 listenA.Wait(tA);
                 listenB.Wait(tB);
-                Assert.Equal(2, pub.Publish("channel", "message"));
+                Assert.Equal(2, pub.Publish(prefix + "channel", "message"));
                 AllowReasonableTimeToPublishAndProcess();
                 Assert.Equal(1, Interlocked.CompareExchange(ref gotA, 0, 0));
                 Assert.Equal(1, Interlocked.CompareExchange(ref gotB, 0, 0));
 
                 // and unsubscibe...
-                tB = listenB.UnsubscribeAsync("chann*", null);
+                tB = listenB.UnsubscribeAsync(prefix + "chann*", null);
                 listenB.Wait(tB);
-                Assert.Equal(1, pub.Publish("channel", "message"));
+                Assert.Equal(1, pub.Publish(prefix + "channel", "message"));
                 AllowReasonableTimeToPublishAndProcess();
                 Assert.Equal(2, Interlocked.CompareExchange(ref gotA, 0, 0));
                 Assert.Equal(1, Interlocked.CompareExchange(ref gotB, 0, 0));
@@ -247,26 +249,27 @@ public void TestSubscribeUnsubscribeAndSubscribeAgain()
             using (var pubMuxer = GetUnsecuredConnection())
             using (var subMuxer = GetUnsecuredConnection())
             {
+                var prefix = Me();
                 var pub = pubMuxer.GetSubscriber();
                 var sub = subMuxer.GetSubscriber();
                 int x = 0, y = 0;
-                var t1 = sub.SubscribeAsync("abc", delegate { Interlocked.Increment(ref x); });
-                var t2 = sub.SubscribeAsync("ab*", delegate { Interlocked.Increment(ref y); });
+                var t1 = sub.SubscribeAsync(prefix + "abc", delegate { Interlocked.Increment(ref x); });
+                var t2 = sub.SubscribeAsync(prefix + "ab*", delegate { Interlocked.Increment(ref y); });
                 sub.WaitAll(t1, t2);
-                pub.Publish("abc", "");
+                pub.Publish(prefix + "abc", "");
                 AllowReasonableTimeToPublishAndProcess();
                 Assert.Equal(1, Volatile.Read(ref x));
                 Assert.Equal(1, Volatile.Read(ref y));
-                t1 = sub.UnsubscribeAsync("abc", null);
-                t2 = sub.UnsubscribeAsync("ab*", null);
+                t1 = sub.UnsubscribeAsync(prefix + "abc", null);
+                t2 = sub.UnsubscribeAsync(prefix + "ab*", null);
                 sub.WaitAll(t1, t2);
-                pub.Publish("abc", "");
+                pub.Publish(prefix + "abc", "");
                 Assert.Equal(1, Volatile.Read(ref x));
                 Assert.Equal(1, Volatile.Read(ref y));
-                t1 = sub.SubscribeAsync("abc", delegate { Interlocked.Increment(ref x); });
-                t2 = sub.SubscribeAsync("ab*", delegate { Interlocked.Increment(ref y); });
+                t1 = sub.SubscribeAsync(prefix + "abc", delegate { Interlocked.Increment(ref x); });
+                t2 = sub.SubscribeAsync(prefix + "ab*", delegate { Interlocked.Increment(ref y); });
                 sub.WaitAll(t1, t2);
-                pub.Publish("abc", "");
+                pub.Publish(prefix + "abc", "");
                 AllowReasonableTimeToPublishAndProcess();
                 Assert.Equal(2, Volatile.Read(ref x));
                 Assert.Equal(2, Volatile.Read(ref y));

StackExchange.Redis.Tests/Booksleeve/Scripting.cs

@@ -62,8 +62,9 @@ public void KeysScripting()
             using (var muxer = GetScriptConn())
             {
                 var conn = muxer.GetDatabase();
-                conn.StringSet("foo", "bar");
-                var result = (string)conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { "foo" }, null);
+                var key = Me();
+                conn.StringSet(key, "bar");
+                var result = (string)conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { key }, null);
                 Assert.Equal("bar", result);
             }
         }
@@ -77,16 +78,17 @@ public void TestRandomThingFromForum()
 
             using (var muxer = GetScriptConn())
             {
+                var prefix = Me();
                 var conn = muxer.GetDatabase();
-                conn.StringSetAsync("A", "0");
-                conn.StringSetAsync("B", "5");
-                conn.StringSetAsync("C", "10");
+                conn.StringSetAsync(prefix + "A", "0");
+                conn.StringSetAsync(prefix + "B", "5");
+                conn.StringSetAsync(prefix + "C", "10");
 
-                var a = conn.ScriptEvaluateAsync(script, new RedisKey[] { "A" }, new RedisValue[] { 6 });
-                var b = conn.ScriptEvaluateAsync(script, new RedisKey[] { "B" }, new RedisValue[] { 6 });
-                var c = conn.ScriptEvaluateAsync(script, new RedisKey[] { "C" }, new RedisValue[] { 6 });
+                var a = conn.ScriptEvaluateAsync(script, new RedisKey[] { prefix + "A" }, new RedisValue[] { 6 });
+                var b = conn.ScriptEvaluateAsync(script, new RedisKey[] { prefix + "B" }, new RedisValue[] { 6 });
+                var c = conn.ScriptEvaluateAsync(script, new RedisKey[] { prefix + "C" }, new RedisValue[] { 6 });
 
-                var vals = conn.StringGetAsync(new RedisKey[] { "A", "B", "C" });
+                var vals = conn.StringGetAsync(new RedisKey[] { prefix + "A", prefix + "B", prefix + "C" });
 
                 Assert.Equal(1, (long)conn.Wait(a)); // exit code when current val is non-positive
                 Assert.Equal(0, (long)conn.Wait(b)); // exit code when result would be negative
@@ -102,9 +104,9 @@ public void HackyGetPerf()
         {
             using (var muxer = GetScriptConn())
             {
+                var key = Me();
                 var conn = muxer.GetDatabase();
-                conn.StringSetAsync("foo", "bar");
-                var key = CreateUniqueName();
+                conn.StringSetAsync(key + "foo", "bar");
                 var result = (long)conn.ScriptEvaluate(@"
 redis.call('psetex', KEYS[1], 60000, 'timing')
 for i = 1,100000 do
@@ -126,23 +128,24 @@ public void MultiIncrWithoutReplies()
             {
                 const int DB = 0; // any database number
                 var conn = muxer.GetDatabase(DB);
+                var prefix = Me();
                 // prime some initial values
-                conn.KeyDeleteAsync(new RedisKey[] { "a", "b", "c" });
-                conn.StringIncrementAsync("b");
-                conn.StringIncrementAsync("c");
-                conn.StringIncrementAsync("c");
+                conn.KeyDeleteAsync(new RedisKey[] { prefix + "a", prefix + "b", prefix + "c" });
+                conn.StringIncrementAsync(prefix + "b");
+                conn.StringIncrementAsync(prefix + "c");
+                conn.StringIncrementAsync(prefix + "c");
 
                 // run the script, passing "a", "b", "c", "c" to
                 // increment a & b by 1, c twice
                 var result = conn.ScriptEvaluateAsync(
                     "for i,key in ipairs(KEYS) do redis.call('incr', key) end",
-                    new RedisKey[] { "a", "b", "c", "c" }, // <== aka "KEYS" in the script
+                    new RedisKey[] { prefix + "a", prefix + "b", prefix + "c", prefix + "c" }, // <== aka "KEYS" in the script
                     null); // <== aka "ARGV" in the script
 
                 // check the incremented values
-                var a = conn.StringGetAsync("a");
-                var b = conn.StringGetAsync("b");
-                var c = conn.StringGetAsync("c");
+                var a = conn.StringGetAsync(prefix + "a");
+                var b = conn.StringGetAsync(prefix + "b");
+                var c = conn.StringGetAsync(prefix + "c");
 
                 Assert.True(conn.Wait(result).IsNull, "result");
                 Assert.Equal(1, (long)conn.Wait(a));
@@ -158,23 +161,24 @@ public void MultiIncrByWithoutReplies()
             {
                 const int DB = 0; // any database number
                 var conn = muxer.GetDatabase(DB);
+                var prefix = Me();
                 // prime some initial values
-                conn.KeyDeleteAsync(new RedisKey[] { "a", "b", "c" });
-                conn.StringIncrementAsync("b");
-                conn.StringIncrementAsync("c");
-                conn.StringIncrementAsync("c");
+                conn.KeyDeleteAsync(new RedisKey[] { prefix + "a", prefix + "b", prefix + "c" });
+                conn.StringIncrementAsync(prefix + "b");
+                conn.StringIncrementAsync(prefix + "c");
+                conn.StringIncrementAsync(prefix + "c");
 
                 //run the script, passing "a", "b", "c" and 1,2,3
                 // increment a &b by 1, c twice
                 var result = conn.ScriptEvaluateAsync(
                     "for i,key in ipairs(KEYS) do redis.call('incrby', key, ARGV[i]) end",
-                    new RedisKey[] { "a", "b", "c" }, // <== aka "KEYS" in the script
+                    new RedisKey[] { prefix + "a", prefix + "b", prefix + "c" }, // <== aka "KEYS" in the script
                     new RedisValue[] { 1, 1, 2 }); // <== aka "ARGV" in the script
 
                 // check the incremented values
-                var a = conn.StringGetAsync("a");
-                var b = conn.StringGetAsync("b");
-                var c = conn.StringGetAsync("c");
+                var a = conn.StringGetAsync(prefix + "a");
+                var b = conn.StringGetAsync(prefix + "b");
+                var c = conn.StringGetAsync(prefix + "c");
 
                 Assert.True(conn.Wait(result).IsNull, "result");
                 Assert.Equal(1, (long)conn.Wait(a));
@@ -189,8 +193,9 @@ public void DisableStringInference()
             using (var muxer = GetScriptConn())
             {
                 var conn = muxer.GetDatabase(0);
-                conn.StringSet("foo", "bar");
-                var result = (byte[])conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { "foo" });
+                var key = Me();
+                conn.StringSet(key, "bar");
+                var result = (byte[])conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { key });
                 Assert.Equal("bar", Encoding.UTF8.GetString(result));
             }
         }
@@ -201,17 +206,18 @@ public void FlushDetection()
             using (var muxer = GetScriptConn(allowAdmin: true))
             {
                 var conn = muxer.GetDatabase(0);
-                conn.StringSet("foo", "bar");
-                var result = (string)conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { "foo" }, null);
+                var key = Me();
+                conn.StringSet(key, "bar");
+                var result = (string)conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { key }, null);
                 Assert.Equal("bar", result);
 
                 // now cause all kinds of problems
                 GetServer(muxer).ScriptFlush();
 
                 //expect this one to <strike>fail</strike> just work fine (self-fix)
-                conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { "foo" }, null);
+                conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { key }, null);
 
-                result = (string)conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { "foo" }, null);
+                result = (string)conn.ScriptEvaluate("return redis.call('get', KEYS[1])", new RedisKey[] { key }, null);
                 Assert.Equal("bar", result);
             }
         }
@@ -326,13 +332,14 @@ public void ChangeDbInScript()
         {
             using (var muxer = GetScriptConn())
             {
-                muxer.GetDatabase(1).StringSet("foo", "db 1");
-                muxer.GetDatabase(2).StringSet("foo", "db 2");
+                var key = Me();
+                muxer.GetDatabase(1).StringSet(key, "db 1");
+                muxer.GetDatabase(2).StringSet(key, "db 2");
 
                 var conn = muxer.GetDatabase(2);
                 var evalResult = conn.ScriptEvaluateAsync(@"redis.call('select', 1)
-        return redis.call('get','foo')", null, null);
-                var getResult = conn.StringGetAsync("foo");
+        return redis.call('get','" + key +"')", null, null);
+                var getResult = conn.StringGetAsync(key);
 
                 Assert.Equal("db 1", (string)conn.Wait(evalResult));
                 // now, our connection thought it was in db 2, but the script changed to db 1
@@ -345,14 +352,15 @@ public void ChangeDbInTranScript()
         {
             using (var muxer = GetScriptConn())
             {
-                muxer.GetDatabase(1).StringSet("foo", "db 1");
-                muxer.GetDatabase(2).StringSet("foo", "db 2");
+                var key = Me();
+                muxer.GetDatabase(1).StringSet(key, "db 1");
+                muxer.GetDatabase(2).StringSet(key, "db 2");
 
                 var conn = muxer.GetDatabase(2);
                 var tran = conn.CreateTransaction();
                 var evalResult = tran.ScriptEvaluateAsync(@"redis.call('select', 1)
-        return redis.call('get','foo')", null, null);
-                var getResult = tran.StringGetAsync("foo");
+        return redis.call('get','" + key + "')", null, null);
+                var getResult = tran.StringGetAsync(key);
                 Assert.True(tran.Execute());
 
                 Assert.Equal("db 1", (string)conn.Wait(evalResult));

StackExchange.Redis.Tests/Issues/SO25567566.cs

@@ -27,7 +27,9 @@ private async Task<string> DoStuff(ConnectionMultiplexer conn)
             var db = conn.GetDatabase();
 
             var timeout = Task.Delay(5000);
-            var len = db.ListLengthAsync("list");
+            var key = Me();
+            var key2 = key + "2";
+            var len = db.ListLengthAsync(key);
 
             if (await Task.WhenAny(timeout, len).ForAwait() != len)
             {
@@ -36,12 +38,12 @@ private async Task<string> DoStuff(ConnectionMultiplexer conn)
 
             if ((await len.ForAwait()) == 0)
             {
-                db.ListRightPush("list", "foo", flags: CommandFlags.FireAndForget);
+                db.ListRightPush(key, "foo", flags: CommandFlags.FireAndForget);
             }
             var tran = db.CreateTransaction();
-            var x = tran.ListRightPopLeftPushAsync("list", "list2");
-            var y = tran.SetAddAsync("set", "bar");
-            var z = tran.KeyExpireAsync("list2", TimeSpan.FromSeconds(60));
+            var x = tran.ListRightPopLeftPushAsync(key, key2);
+            var y = tran.SetAddAsync(key + "set", "bar");
+            var z = tran.KeyExpireAsync(key2, TimeSpan.FromSeconds(60));
             timeout = Task.Delay(5000);
 
             var exec = tran.ExecuteAsync();
@@ -56,7 +58,7 @@ private async Task<string> DoStuff(ConnectionMultiplexer conn)
                     await Task.WhenAll(x, y, z).ForAwait();
 
                     var db2 = conn.GetDatabase();
-                    db2.HashGet("hash", "whatever");
+                    db2.HashGet(key + "hash", "whatever");
                     return "ok";
                 }
                 else

StackExchange.Redis.Tests/Locking.cs

@@ -33,6 +33,7 @@ public void AggressiveParallel(TestMode testMode)
             int errorCount = 0;
             int bgErrorCount = 0;
             var evt = new ManualResetEvent(false);
+            var key = Me();
             using (var c1 = Create(testMode))
             using (var c2 = Create(testMode))
             {
@@ -45,7 +46,7 @@ void cb(object obj)
 
                         for (int i = 0; i < 1000; i++)
                         {
-                            conn.LockTakeAsync("abc", "def", TimeSpan.FromSeconds(5));
+                            conn.LockTakeAsync(key, "def", TimeSpan.FromSeconds(5));
                         }
                         conn.Ping();
                         if (Interlocked.Decrement(ref count) == 0) evt.Set();
@@ -153,7 +154,7 @@ public void TakeLockAndExtend(TestMode mode)
                     wrong = Guid.NewGuid().ToString();
 
                 int DB = mode == TestMode.Twemproxy ? 0 : 7;
-                RedisKey Key = "lock-key";
+                RedisKey Key = Me();
 
                 var db = conn.GetDatabase(DB);
 
@@ -237,12 +238,13 @@ public void TestBasicLockNotTaken(TestMode testMode)
 
                 const int LOOP = 50;
                 var db = conn.GetDatabase(0);
+                var key = Me();
                 for (int i = 0; i < LOOP; i++)
                 {
-                    db.KeyDeleteAsync("lock-not-exists");
-                    taken = db.LockTakeAsync("lock-not-exists", "new-value", TimeSpan.FromSeconds(10));
-                    newValue = db.StringGetAsync("lock-not-exists");
-                    ttl = db.KeyTimeToLiveAsync("lock-not-exists");
+                    db.KeyDeleteAsync(key);
+                    taken = db.LockTakeAsync(key, "new-value", TimeSpan.FromSeconds(10));
+                    newValue = db.StringGetAsync(key);
+                    ttl = db.KeyTimeToLiveAsync(key);
                 }
                 Assert.True(conn.Wait(taken), "taken");
                 Assert.Equal("new-value", (string)conn.Wait(newValue));
@@ -259,11 +261,12 @@ public void TestBasicLockTaken(TestMode testMode)
             using (var conn = Create(testMode))
             {
                 var db = conn.GetDatabase(0);
-                db.KeyDelete("lock-exists");
-                db.StringSet("lock-exists", "old-value", TimeSpan.FromSeconds(20));
-                var taken = db.LockTakeAsync("lock-exists", "new-value", TimeSpan.FromSeconds(10));
-                var newValue = db.StringGetAsync("lock-exists");
-                var ttl = db.KeyTimeToLiveAsync("lock-exists");
+                var key = Me();
+                db.KeyDelete(key);
+                db.StringSet(key, "old-value", TimeSpan.FromSeconds(20));
+                var taken = db.LockTakeAsync(key, "new-value", TimeSpan.FromSeconds(10));
+                var newValue = db.StringGetAsync(key);
+                var ttl = db.KeyTimeToLiveAsync(key);
 
                 Assert.False(conn.Wait(taken), "taken");
                 Assert.Equal("old-value", (string)conn.Wait(newValue));

StackExchange.Redis.Tests/Scans.cs

@@ -20,20 +20,21 @@ public void KeysScan(bool supported)
             {
                 const int DB = 7;
                 var db = conn.GetDatabase(DB);
+                var prefix = Me() + ":";
                 var server = GetServer(conn);
                 server.FlushDatabase(DB);
                 for (int i = 0; i < 100; i++)
                 {
-                    db.StringSet("KeysScan:" + i, Guid.NewGuid().ToString(), flags: CommandFlags.FireAndForget);
+                    db.StringSet(prefix + i, Guid.NewGuid().ToString(), flags: CommandFlags.FireAndForget);
                 }
                 var seq = server.Keys(DB, pageSize: 50);
                 bool isScanning = seq is IScanningCursor;
                 Assert.Equal(supported, isScanning);
                 Assert.Equal(100, seq.Distinct().Count());
                 Assert.Equal(100, seq.Distinct().Count());
-                Assert.Equal(100, server.Keys(DB, "KeysScan:*").Distinct().Count());
+                Assert.Equal(100, server.Keys(DB, prefix + "*").Distinct().Count());
                 // 7, 70, 71, ..., 79
-                Assert.Equal(11, server.Keys(DB, "KeysScan:7*").Distinct().Count());
+                Assert.Equal(11, server.Keys(DB, prefix + "7*").Distinct().Count());
             }
         }
 
@@ -195,7 +196,7 @@ public void SortedSetScan(bool supported)
             string[] disabledCommands = supported ? null : new[] { "zscan" };
             using (var conn = Create(disabledCommands: disabledCommands))
             {
-                RedisKey key = Me();
+                RedisKey key = Me() + supported;
                 var db = conn.GetDatabase();
                 db.KeyDelete(key);
 
@@ -304,7 +305,7 @@ public void HashScanLarge(int pageSize)
         {
             using (var conn = Create())
             {
-                RedisKey key = Me();
+                RedisKey key = Me() + pageSize;
                 var db = conn.GetDatabase();
                 db.KeyDelete(key);
 
@@ -364,7 +365,7 @@ public void SetScanLarge(int pageSize)
         {
             using (var conn = Create())
             {
-                RedisKey key = Me();
+                RedisKey key = Me() + pageSize;
                 var db = conn.GetDatabase();
                 db.KeyDelete(key);
 
@@ -385,7 +386,7 @@ public void SortedSetScanLarge(int pageSize)
         {
             using (var conn = Create())
             {
-                RedisKey key = Me();
+                RedisKey key = Me() + pageSize;
                 var db = conn.GetDatabase();
                 db.KeyDelete(key);
 

StackExchange.Redis.Tests/Scripting.cs

@@ -112,7 +112,7 @@ public void CompareScriptToDirect()
 
                 // we're using a pipeline here, so send 1000 messages, but for timing: only care about the last
                 const int LOOP = 5000;
-                RedisKey key = "foo";
+                RedisKey key = Me();
                 RedisKey[] keys = new[] { key }; // script takes an array
 
                 // run via script

StackExchange.Redis.Tests/WithKeyPrefixTests.cs

@@ -74,7 +74,8 @@ public void BasicSmokeTest()
             {
                 var raw = conn.GetDatabase(1);
 
-                var foo = raw.WithKeyPrefix("foo");
+                var prefix = Me();
+                var foo = raw.WithKeyPrefix(prefix);
                 var foobar = foo.WithKeyPrefix("bar");
 
                 string key = Me();
@@ -92,10 +93,10 @@ public void BasicSmokeTest()
                 val = (string)foo.StringGet("bar" + key);
                 Assert.Equal(t, val); // foobarBasicSmokeTest
 
-                val = (string)raw.StringGet("foo" + key);
+                val = (string)raw.StringGet(prefix + key);
                 Assert.Equal(s, val); // fooBasicSmokeTest
 
-                val = (string)raw.StringGet("foobar" + key);
+                val = (string)raw.StringGet(prefix + "bar" + key);
                 Assert.Equal(t, val); // foobarBasicSmokeTest
             }
         }