Test: Split failover test servers out

This could be a terrible idea, but I hope it helps isolate failures and increase stability a bit.

RedisConfigs/Failover/master-6382.conf

+port 6382
+repl-diskless-sync yes
+repl-diskless-sync-delay 0
+databases 2000
+maxmemory 2gb
+dir "../Temp"
+appendonly no
+dbfilename "master-6382.rdb"
+save ""
\ No newline at end of file

RedisConfigs/Failover/slave-6383.conf

+port 6383
+slaveof 127.0.0.1 6382
+repl-diskless-sync yes
+repl-diskless-sync-delay 0
+databases 2000
+maxmemory 2gb
+appendonly no
+dir "../Temp"
+dbfilename "slave-6383.rdb"
+save ""
\ No newline at end of file

RedisConfigs/start-all.cmd

 @echo off
 echo Starting Redis servers for testing...
 call %~dp0\start-basic.cmd
+call %~dp0\start-failover.cmd
 call %~dp0\start-cluster.cmd
 call %~dp0\start-sentinel.cmd
 echo Servers started (minimized).

RedisConfigs/start-failover.cmd

+@echo off
+echo Starting Failover:
+pushd %~dp0\Failover
+echo   Master: 6382
+@start "Redis (Failover Master): 6382" /min ..\3.0.503\redis-server.exe master-6382.conf
+echo   Slave: 6383
+@start "Redis (Failover Slave): 6383" /min ..\3.0.503\redis-server.exe slave-6383.conf
+popd
\ No newline at end of file

StackExchange.Redis.Tests/Config.cs

@@ -14,40 +14,6 @@ public class Config : TestBase
     {
         public Config(ITestOutputHelper output) : base (output) { }
 
-        [Fact]
-        public async Task VerifyReceiveConfigChangeBroadcast()
-        {
-            var config = GetConfiguration();
-            using (var sender = Create(allowAdmin: true))
-            using (var receiver = Create(syncTimeout: 2000))
-            {
-                int total = 0;
-                receiver.ConfigurationChangedBroadcast += (s, a) =>
-                {
-                    Output.WriteLine("Config changed: " + (a.EndPoint == null ? "(none)" : a.EndPoint.ToString()));
-                    Interlocked.Increment(ref total);
-                };
-                // send a reconfigure/reconnect message
-                long count = sender.PublishReconfigure();
-                GetServer(receiver).Ping();
-                GetServer(receiver).Ping();
-                await Task.Delay(10).ConfigureAwait(false);
-                Assert.True(count == -1 || count >= 2, "subscribers");
-                Assert.True(Interlocked.CompareExchange(ref total, 0, 0) >= 1, "total (1st)");
-
-                Interlocked.Exchange(ref total, 0);
-
-                // and send a second time via a re-master operation
-                var server = GetServer(sender);
-                if (server.IsSlave) Skip.Inconclusive("didn't expect a slave");
-                server.MakeMaster(ReplicationChangeOptions.Broadcast);
-                await Task.Delay(100).ConfigureAwait(false);
-                GetServer(receiver).Ping();
-                GetServer(receiver).Ping();
-                Assert.True(Interlocked.CompareExchange(ref total, 0, 0) >= 1, "total (2nd)");
-            }
-        }
-
         [Fact]
         public void TalkToNonsenseServer()
         {

StackExchange.Redis.Tests/PubSubNonParallel.cs → StackExchange.Redis.Tests/Failover.cs

@@ -6,31 +6,145 @@
 
 namespace StackExchange.Redis.Tests
 {
-    [Collection(NonParallelCollection.Name)]
-    public class PubSubNonParallel : TestBase
+    public class Failover : TestBase
     {
-        private async Task EnsureMasterSlaveSetupAsync(ConnectionMultiplexer mutex)
+        protected override string GetConfiguration() => GetMasterSlaveConfig().ToString();
+        public Failover(ITestOutputHelper output) : base(output) { }
+
+        private static ConfigurationOptions GetMasterSlaveConfig()
         {
-            var shouldBeMaster = mutex.GetServer(TestConfig.Current.MasterServerAndPort);
-            if (shouldBeMaster.IsSlave)
+            return new ConfigurationOptions
             {
-                Output.WriteLine(shouldBeMaster.EndPoint + " should be master, fixing...");
-                shouldBeMaster.MakeMaster(ReplicationChangeOptions.SetTiebreaker);
+                AllowAdmin = true,
+                SyncTimeout = 100000,
+                EndPoints =
+                {
+                    { TestConfig.Current.FailoverMasterServer, TestConfig.Current.FailoverMasterPort },
+                    { TestConfig.Current.FailoverSlaveServer, TestConfig.Current.FailoverSlavePort },
+                }
+            };
         }
 
-            Output.WriteLine("Flushing all databases...");
-            shouldBeMaster.FlushAllDatabases(CommandFlags.FireAndForget);
+        [Fact]
+        public async Task ConfigVerifyReceiveConfigChangeBroadcast()
+        {
+            var config = GetConfiguration();
+            using (var sender = Create(allowAdmin: true))
+            using (var receiver = Create(syncTimeout: 2000))
+            {
+                int total = 0;
+                receiver.ConfigurationChangedBroadcast += (s, a) =>
+                {
+                    Output.WriteLine("Config changed: " + (a.EndPoint == null ? "(none)" : a.EndPoint.ToString()));
+                    Interlocked.Increment(ref total);
+                };
+                // send a reconfigure/reconnect message
+                long count = sender.PublishReconfigure();
+                GetServer(receiver).Ping();
+                GetServer(receiver).Ping();
+                await Task.Delay(10).ConfigureAwait(false);
+                Assert.True(count == -1 || count >= 2, "subscribers");
+                Assert.True(Interlocked.CompareExchange(ref total, 0, 0) >= 1, "total (1st)");
 
-            var shouldBeReplica = mutex.GetServer(TestConfig.Current.SlaveServerAndPort);
-            if (!shouldBeReplica.IsSlave)
+                Interlocked.Exchange(ref total, 0);
+
+                // and send a second time via a re-master operation
+                var server = GetServer(sender);
+                if (server.IsSlave) Skip.Inconclusive("didn't expect a slave");
+                server.MakeMaster(ReplicationChangeOptions.Broadcast);
+                await Task.Delay(100).ConfigureAwait(false);
+                GetServer(receiver).Ping();
+                GetServer(receiver).Ping();
+                Assert.True(Interlocked.CompareExchange(ref total, 0, 0) >= 1, "total (2nd)");
+            }
+        }
+
+        [Fact]
+        public async Task DeslaveGoesToPrimary()
         {
-                Output.WriteLine(shouldBeReplica.EndPoint + " should be a slave, fixing...");
-                shouldBeReplica.SlaveOf(shouldBeMaster.EndPoint);
-                await Task.Delay(1000).ForAwait();
+            ConfigurationOptions config = GetMasterSlaveConfig();
+            using (var conn = ConnectionMultiplexer.Connect(config))
+            {
+                var primary = conn.GetServer(TestConfig.Current.FailoverMasterServerAndPort);
+                var secondary = conn.GetServer(TestConfig.Current.FailoverSlaveServerAndPort);
+
+                primary.Ping();
+                secondary.Ping();
+
+                primary.MakeMaster(ReplicationChangeOptions.SetTiebreaker);
+                secondary.MakeMaster(ReplicationChangeOptions.None);
+
+                await Task.Delay(100).ConfigureAwait(false);
+
+                primary.Ping();
+                secondary.Ping();
+
+                using (var writer = new StringWriter())
+                {
+                    conn.Configure(writer);
+                    string log = writer.ToString();
+
+                    Assert.True(log.Contains("tie-break is unanimous at " + TestConfig.Current.FailoverMasterServerAndPort), "unanimous");
                 }
+                // k, so we know everyone loves 6379; is that what we get?
+
+                var db = conn.GetDatabase();
+                RedisKey key = Me();
+
+                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferMaster));
+                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.DemandMaster));
+                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferSlave));
+
+                var ex = Assert.Throws<RedisConnectionException>(() => db.IdentifyEndpoint(key, CommandFlags.DemandSlave));
+                Assert.StartsWith("No connection is available to service this operation: EXISTS " + Me(), ex.Message);
+                Writer.WriteLine("Invoking MakeMaster()...");
+                primary.MakeMaster(ReplicationChangeOptions.Broadcast | ReplicationChangeOptions.EnslaveSubordinates | ReplicationChangeOptions.SetTiebreaker, Writer);
+                Writer.WriteLine("Finished MakeMaster() call.");
+
+                await Task.Delay(100).ConfigureAwait(false);
+
+                Writer.WriteLine("Invoking Ping() (post-master)");
+                primary.Ping();
+                secondary.Ping();
+                Writer.WriteLine("Finished Ping() (post-master)");
+
+                Assert.True(primary.IsConnected, $"{primary.EndPoint} is not connected.");
+                Assert.True(secondary.IsConnected, $"{secondary.EndPoint} is not connected.");
+
+                Writer.WriteLine($"{primary.EndPoint}: {primary.ServerType}, Mode: {(primary.IsSlave ? "Slave" : "Master")}");
+                Writer.WriteLine($"{secondary.EndPoint}: {secondary.ServerType}, Mode: {(secondary.IsSlave ? "Slave" : "Master")}");
+
+                // Create a separate multiplexer with a valid view of the world to distinguish between failures of
+                // server topology changes from failures to recognize those changes
+                Writer.WriteLine("Connecting to secondary validation connection.");
+                using (var conn2 = ConnectionMultiplexer.Connect(config))
+                {
+                    var primary2 = conn.GetServer(TestConfig.Current.FailoverMasterServerAndPort);
+                    var secondary2 = conn.GetServer(TestConfig.Current.FailoverSlaveServerAndPort);
+
+                    Writer.WriteLine($"Check: {primary2.EndPoint}: {primary2.ServerType}, Mode: {(primary2.IsSlave ? "Slave" : "Master")}");
+                    Writer.WriteLine($"Check: {secondary2.EndPoint}: {secondary2.ServerType}, Mode: {(secondary2.IsSlave ? "Slave" : "Master")}");
+
+                    Assert.False(primary2.IsSlave, $"{primary2.EndPoint} should be a master (verification connection).");
+                    Assert.True(secondary2.IsSlave, $"{secondary2.EndPoint} should be a slave (verification connection).");
+
+                    var db2 = conn.GetDatabase();
+
+                    Assert.Equal(primary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.PreferMaster));
+                    Assert.Equal(primary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.DemandMaster));
+                    Assert.Equal(secondary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.PreferSlave));
+                    Assert.Equal(secondary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.DemandSlave));
                 }
 
-        public PubSubNonParallel(ITestOutputHelper output) : base(output) { }
+                Assert.False(primary.IsSlave, $"{primary.EndPoint} should be a master.");
+                Assert.True(secondary.IsSlave, $"{secondary.EndPoint} should be a slave.");
+
+                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferMaster));
+                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.DemandMaster));
+                Assert.Equal(secondary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferSlave));
+                Assert.Equal(secondary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.DemandSlave));
+            }
+        }
 
         [Theory]
         [InlineData(false)]
@@ -68,10 +182,10 @@ public async Task SubscriptionsSurviveMasterSwitchAsync(bool useSharedSocketMana
                         Interlocked.Increment(ref bCount);
                     });
 
-                    Assert.False(a.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.MasterServerAndPort} should be a master");
-                    Assert.True(a.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.SlaveServerAndPort} should be a slave");
-                    Assert.False(b.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.MasterServerAndPort} should be a master");
-                    Assert.True(b.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.SlaveServerAndPort} should be a slave");
+                    Assert.False(a.GetServer(TestConfig.Current.FailoverMasterServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.FailoverMasterServerAndPort} should be a master");
+                    Assert.True(a.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.FailoverSlaveServerAndPort} should be a slave");
+                    Assert.False(b.GetServer(TestConfig.Current.FailoverMasterServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.FailoverMasterServerAndPort} should be a master");
+                    Assert.True(b.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.FailoverSlaveServerAndPort} should be a slave");
 
                     var epA = subA.SubscribedEndpoint(channel);
                     var epB = subB.SubscribedEndpoint(channel);
@@ -94,22 +208,22 @@ public async Task SubscriptionsSurviveMasterSwitchAsync(bool useSharedSocketMana
                         Output.WriteLine("Changing master...");
                         using (var sw = new StringWriter())
                         {
-                            a.GetServer(TestConfig.Current.SlaveServerAndPort).MakeMaster(ReplicationChangeOptions.All, sw);
+                            a.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).MakeMaster(ReplicationChangeOptions.All, sw);
                             Output.WriteLine(sw.ToString());
                         }
                         await Task.Delay(5000).ForAwait();
                         subA.Ping();
                         subB.Ping();
                         Output.WriteLine("Pausing...");
-                        Output.WriteLine("A " + TestConfig.Current.MasterServerAndPort + " status: " + (a.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave ? "Slave" : "Master"));
-                        Output.WriteLine("A " + TestConfig.Current.SlaveServerAndPort + " status: " + (a.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave ? "Slave" : "Master"));
-                        Output.WriteLine("B " + TestConfig.Current.MasterServerAndPort + " status: " + (b.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave ? "Slave" : "Master"));
-                        Output.WriteLine("B " + TestConfig.Current.SlaveServerAndPort + " status: " + (b.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave ? "Slave" : "Master"));
+                        Output.WriteLine("A " + TestConfig.Current.FailoverMasterServerAndPort + " status: " + (a.GetServer(TestConfig.Current.FailoverMasterServerAndPort).IsSlave ? "Slave" : "Master"));
+                        Output.WriteLine("A " + TestConfig.Current.FailoverSlaveServerAndPort + " status: " + (a.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).IsSlave ? "Slave" : "Master"));
+                        Output.WriteLine("B " + TestConfig.Current.FailoverMasterServerAndPort + " status: " + (b.GetServer(TestConfig.Current.FailoverMasterServerAndPort).IsSlave ? "Slave" : "Master"));
+                        Output.WriteLine("B " + TestConfig.Current.FailoverSlaveServerAndPort + " status: " + (b.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).IsSlave ? "Slave" : "Master"));
 
-                        Assert.True(a.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.MasterServerAndPort} should be a slave");
-                        Assert.False(a.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.SlaveServerAndPort} should be a master");
-                        Assert.True(b.GetServer(TestConfig.Current.MasterServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.MasterServerAndPort} should be a slave");
-                        Assert.False(b.GetServer(TestConfig.Current.SlaveServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.SlaveServerAndPort} should be a master");
+                        Assert.True(a.GetServer(TestConfig.Current.FailoverMasterServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.FailoverMasterServerAndPort} should be a slave");
+                        Assert.False(a.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).IsSlave, $"A Connection: {TestConfig.Current.FailoverSlaveServerAndPort} should be a master");
+                        Assert.True(b.GetServer(TestConfig.Current.FailoverMasterServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.FailoverMasterServerAndPort} should be a slave");
+                        Assert.False(b.GetServer(TestConfig.Current.FailoverSlaveServerAndPort).IsSlave, $"B Connection: {TestConfig.Current.FailoverSlaveServerAndPort} should be a master");
 
                         Output.WriteLine("Pause complete");
                         Output.WriteLine("A outstanding: " + a.GetCounters().TotalOutstanding);
@@ -137,7 +251,7 @@ public async Task SubscriptionsSurviveMasterSwitchAsync(bool useSharedSocketMana
                         Output.WriteLine("Restoring configuration...");
                         try
                         {
-                            a.GetServer(TestConfig.Current.MasterServerAndPort).MakeMaster(ReplicationChangeOptions.All);
+                            a.GetServer(TestConfig.Current.FailoverMasterServerAndPort).MakeMaster(ReplicationChangeOptions.All);
                             await Task.Delay(1000).ForAwait();
                         }
                         catch { }
@@ -150,5 +264,26 @@ public async Task SubscriptionsSurviveMasterSwitchAsync(bool useSharedSocketMana
                 }
             }
         }
+
+        protected async Task EnsureMasterSlaveSetupAsync(ConnectionMultiplexer mutex)
+        {
+            var shouldBeMaster = mutex.GetServer(TestConfig.Current.FailoverMasterServerAndPort);
+            if (shouldBeMaster.IsSlave)
+            {
+                Output.WriteLine(shouldBeMaster.EndPoint + " should be master, fixing...");
+                shouldBeMaster.MakeMaster(ReplicationChangeOptions.SetTiebreaker);
+            }
+
+            Output.WriteLine("Flushing all databases...");
+            shouldBeMaster.FlushAllDatabases(CommandFlags.FireAndForget);
+
+            var shouldBeReplica = mutex.GetServer(TestConfig.Current.FailoverSlaveServerAndPort);
+            if (!shouldBeReplica.IsSlave)
+            {
+                Output.WriteLine(shouldBeReplica.EndPoint + " should be a slave, fixing...");
+                shouldBeReplica.SlaveOf(shouldBeMaster.EndPoint);
+                await Task.Delay(1000).ForAwait();
+            }
+        }
     }
 }

StackExchange.Redis.Tests/Helpers/TestConfig.cs

@@ -50,6 +50,15 @@ public class Config
             public string SecurePassword { get; set; } = "changeme";
             public string SecureServerAndPort => SecureServer + ":" + SecurePort.ToString();
 
+            // Separate servers for failover tests, so they don't wreak havoc on all others
+            public string FailoverMasterServer { get; set; } = "127.0.0.1";
+            public int FailoverMasterPort { get; set; } = 6382;
+            public string FailoverMasterServerAndPort => FailoverMasterServer + ":" + FailoverMasterPort.ToString();
+
+            public string FailoverSlaveServer { get; set; } = "127.0.0.1";
+            public int FailoverSlavePort { get; set; } = 6383;
+            public string FailoverSlaveServerAndPort => FailoverSlaveServer + ":" + FailoverSlavePort.ToString();
+
             public string IPv4Server { get; set; } = "127.0.0.1";
             public int IPv4Port { get; set; } = 6379;
             public string IPv6Server { get; set; } = "::1";

StackExchange.Redis.Tests/MultiMaster.cs

 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace StackExchange.Redis.Tests
 {
-    [Collection(NonParallelCollection.Name)]
     public class MultiMaster : TestBase
     {
         protected override string GetConfiguration() =>
             TestConfig.Current.MasterServerAndPort + "," + TestConfig.Current.SecureServerAndPort + ",password=" + TestConfig.Current.SecurePassword;
-
         public MultiMaster(ITestOutputHelper output) : base (output) { }
 
         [Fact]
@@ -20,8 +17,7 @@ public void CannotFlushSlave()
         {
             var ex = Assert.Throws<RedisCommandException>(() =>
             {
-                ConfigurationOptions config = GetMasterSlaveConfig();
-                using (var conn = ConnectionMultiplexer.Connect(config))
+                using (var conn = ConnectionMultiplexer.Connect(TestConfig.Current.SlaveServerAndPort + ",allowAdmin=true"))
                 {
                     var servers = conn.GetEndPoints().Select(e => conn.GetServer(e));
                     var slave = servers.FirstOrDefault(x => x.IsSlave);
@@ -32,107 +28,6 @@ public void CannotFlushSlave()
             Assert.Equal("Command cannot be issued to a slave: FLUSHDB", ex.Message);
         }
 
-        [Fact]
-        public async Task DeslaveGoesToPrimary()
-        {
-            ConfigurationOptions config = GetMasterSlaveConfig();
-            using (var conn = ConnectionMultiplexer.Connect(config))
-            {
-                var primary = conn.GetServer(TestConfig.Current.MasterServerAndPort);
-                var secondary = conn.GetServer(TestConfig.Current.SlaveServerAndPort);
-
-                primary.Ping();
-                secondary.Ping();
-
-                primary.MakeMaster(ReplicationChangeOptions.SetTiebreaker);
-                secondary.MakeMaster(ReplicationChangeOptions.None);
-
-                await Task.Delay(100).ConfigureAwait(false);
-
-                primary.Ping();
-                secondary.Ping();
-
-                using (var writer = new StringWriter())
-                {
-                    conn.Configure(writer);
-                    string log = writer.ToString();
-
-                    Assert.True(log.Contains("tie-break is unanimous at " + TestConfig.Current.MasterServerAndPort), "unanimous");
-                }
-                // k, so we know everyone loves 6379; is that what we get?
-
-                var db = conn.GetDatabase();
-                RedisKey key = Me();
-
-                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferMaster));
-                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.DemandMaster));
-                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferSlave));
-
-                var ex = Assert.Throws<RedisConnectionException>(() => db.IdentifyEndpoint(key, CommandFlags.DemandSlave));
-                Assert.StartsWith("No connection is available to service this operation: EXISTS " + Me(), ex.Message);
-                Writer.WriteLine("Invoking MakeMaster()...");
-                primary.MakeMaster(ReplicationChangeOptions.Broadcast | ReplicationChangeOptions.EnslaveSubordinates | ReplicationChangeOptions.SetTiebreaker, Writer);
-                Writer.WriteLine("Finished MakeMaster() call.");
-
-                await Task.Delay(100).ConfigureAwait(false);
-
-                Writer.WriteLine("Invoking Ping() (post-master)");
-                primary.Ping();
-                secondary.Ping();
-                Writer.WriteLine("Finished Ping() (post-master)");
-
-                Assert.True(primary.IsConnected, $"{primary.EndPoint} is not connected.");
-                Assert.True(secondary.IsConnected, $"{secondary.EndPoint} is not connected.");
-
-                Writer.WriteLine($"{primary.EndPoint}: {primary.ServerType}, Mode: {(primary.IsSlave ? "Slave" : "Master")}");
-                Writer.WriteLine($"{secondary.EndPoint}: {secondary.ServerType}, Mode: {(secondary.IsSlave ? "Slave" : "Master")}");
-
-                // Create a separate multiplexer with a valid view of the world to distinguish between failures of
-                // server topology changes from failures to recognize those changes
-                Writer.WriteLine("Connecting to secondary validation connection.");
-                using (var conn2 = ConnectionMultiplexer.Connect(config))
-                {
-                    var primary2 = conn.GetServer(TestConfig.Current.MasterServerAndPort);
-                    var secondary2 = conn.GetServer(TestConfig.Current.SlaveServerAndPort);
-
-                    Writer.WriteLine($"Check: {primary2.EndPoint}: {primary2.ServerType}, Mode: {(primary2.IsSlave ? "Slave" : "Master")}");
-                    Writer.WriteLine($"Check: {secondary2.EndPoint}: {secondary2.ServerType}, Mode: {(secondary2.IsSlave ? "Slave" : "Master")}");
-
-                    Assert.False(primary2.IsSlave, $"{primary2.EndPoint} should be a master (verification connection).");
-                    Assert.True(secondary2.IsSlave, $"{secondary2.EndPoint} should be a slave (verification connection).");
-
-                    var db2 = conn.GetDatabase();
-
-                    Assert.Equal(primary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.PreferMaster));
-                    Assert.Equal(primary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.DemandMaster));
-                    Assert.Equal(secondary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.PreferSlave));
-                    Assert.Equal(secondary2.EndPoint, db2.IdentifyEndpoint(key, CommandFlags.DemandSlave));
-                }
-
-                Assert.False(primary.IsSlave, $"{primary.EndPoint} should be a master.");
-                Assert.True(secondary.IsSlave, $"{secondary.EndPoint} should be a slave.");
-
-                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferMaster));
-                Assert.Equal(primary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.DemandMaster));
-                Assert.Equal(secondary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.PreferSlave));
-                Assert.Equal(secondary.EndPoint, db.IdentifyEndpoint(key, CommandFlags.DemandSlave));
-            }
-        }
-
-        private static ConfigurationOptions GetMasterSlaveConfig()
-        {
-            return new ConfigurationOptions
-            {
-                AllowAdmin = true,
-                SyncTimeout = 100000,
-                EndPoints =
-                {
-                    { TestConfig.Current.MasterServer, TestConfig.Current.MasterPort },
-                    { TestConfig.Current.SlaveServer, TestConfig.Current.SlavePort },
-                }
-            };
-        }
-
         [Fact]
         public void TestMultiNoTieBreak()
         {

StackExchange.Redis.Tests/PubSub.cs

@@ -7,7 +7,6 @@
 
 namespace StackExchange.Redis.Tests
 {
-    [Collection(NonParallelCollection.Name)]
     public class PubSub : TestBase
     {
         public PubSub(ITestOutputHelper output) : base(output) { }
@@ -194,11 +193,6 @@ private static void Ping(ConnectionMultiplexer muxer, IServer pub, ISubscriber s
             }
         }
 
-        //protected override string GetConfiguration()
-        //{
-        //    return TestConfig.Current.MasterServer + ":" + TestConfig.Current.MasterPort;
-        //}
-
         [Theory]
         [InlineData(true)]
         [InlineData(false)]

appveyor.yml

@@ -13,6 +13,10 @@ install:
 
     redis-server.exe --service-install --service-name "redis-6381" "..\Basic\secure-6381.conf"
 
+    redis-server.exe --service-install --service-name "redis-6382" "..\Failover\master-6382.conf"
+
+    redis-server.exe --service-install --service-name "redis-6382" "..\Failover\slave-6383.conf"
+
     redis-server.exe --service-install --service-name "redis-7000" "..\Cluster\cluster-7000.conf" --dir "..\Cluster"
 
     redis-server.exe --service-install --service-name "redis-7001" "..\Cluster\cluster-7001.conf" --dir "..\Cluster"