@@ -95,7 +95,7 @@ Expected servers (defaults in `tests/StackExchange.Redis.Tests/Helpers/TestConfi
 - `7000`-`7005` cluster nodes
 - `7010`/`7011` + `26379`-`26381` sentinel
 
-Tests skip as *inconclusive* when their required server is absent (e.g. cluster tests skip with "Unable to connect to server"). Override hosts/ports for local runs with a `tests/StackExchange.Redis.Tests/TestConfig.json` (gitignored). A stray container squatting on `6379` is a common failure: it makes the primary reachable but leaves no replica/cluster, so replica/cluster tests fail or skip — clear it before bringing the compose up.
+Tests skip as *inconclusive* when their required server is absent (e.g. cluster tests skip with "Unable to connect to server"). Override hosts/ports for local runs by editing `tests/StackExchange.Redis.Tests/RedisTestConfig.json` — note that it is **tracked**, and is read as an *embedded resource* rather than from disk, so changes need a rebuild and show up as a dirty working tree rather than acting as a private override. `RunLongRunning` there also unlocks the tests gated behind `Skip.UnlessLongRunning()`, which CI never runs. A stray container squatting on `6379` is a common failure: it makes the primary reachable but leaves no replica/cluster, so replica/cluster tests fail or skip — clear it before bringing the compose up.
 
 To probe these servers ad hoc, the local user may have `resp-cli` installed — a `dotnet` global tool that is functionally similar to `redis-cli` (same basic flags: `-p`, `-a`, `-n`, `--tls`, `-3`). Prefer `resp-cli` when it's available; fall back to `redis-cli` otherwise.
 
 
@@ -76,8 +76,11 @@ public async Task CountKeys()
             Skip.IfMissingDatabase(conn, db1Id);
             Skip.IfMissingDatabase(conn, db2Id);
             var server = GetAnyPrimary(conn);
-            server.FlushDatabase(db1Id, CommandFlags.FireAndForget);
-            server.FlushDatabase(db2Id, CommandFlags.FireAndForget);
+
+            // awaited, not fire-and-forget: the writes below happen on a *different* connection, so nothing
+            // orders them against these flushes, and an unlucky run counts the leftovers too
+            await server.FlushDatabaseAsync(db1Id);
+            await server.FlushDatabaseAsync(db2Id);
         }
         await using (var conn = Create(defaultDatabase: db2Id))
         {
 
@@ -41,14 +41,18 @@ public async Task GetLatest()
         Skip.UnlessLongRunning();
         await using var conn = Create(allowAdmin: true);
 
-        var server = conn.GetServer(conn.GetEndPoints()[0]);
+        var server = GetAnyPrimary(conn);
         server.ConfigSet("latency-monitor-threshold", 50);
         server.LatencyReset();
         var arr = server.LatencyLatest();
         Assert.Empty(arr);
 
         var now = await server.TimeAsync();
-        server.Execute("debug", "sleep", "0.5"); // cause something to be slow
+        // Via IDatabase, not IServer: DEBUG is not in Message.RequiresDatabase's exclusion list, so
+        // IServer.Execute - which has no database to offer - refuses it outright (see #3236).
+        // DemandMaster so this provably lands on the same node being measured above, rather than
+        // relying on the test topology happening to expose a single endpoint.
+        conn.GetDatabase().Execute("debug", ["sleep", "0.5"], CommandFlags.DemandMaster); // cause something to be slow
 
         arr = await server.LatencyLatestAsync();
         var item = Assert.Single(arr);
@@ -64,14 +68,18 @@ public async Task GetHistory()
         Skip.UnlessLongRunning();
         await using var conn = Create(allowAdmin: true);
 
-        var server = conn.GetServer(conn.GetEndPoints()[0]);
+        var server = GetAnyPrimary(conn);
         server.ConfigSet("latency-monitor-threshold", 50);
         server.LatencyReset();
         var arr = server.LatencyHistory("command");
         Assert.Empty(arr);
 
         var now = await server.TimeAsync();
-        server.Execute("debug", "sleep", "0.5"); // cause something to be slow
+        // Via IDatabase, not IServer: DEBUG is not in Message.RequiresDatabase's exclusion list, so
+        // IServer.Execute - which has no database to offer - refuses it outright (see #3236).
+        // DemandMaster so this provably lands on the same node being measured above, rather than
+        // relying on the test topology happening to expose a single endpoint.
+        conn.GetDatabase().Execute("debug", ["sleep", "0.5"], CommandFlags.DemandMaster); // cause something to be slow
 
         arr = await server.LatencyHistoryAsync("command");
         var item = Assert.Single(arr);
 
@@ -41,15 +41,16 @@ private static InProcessTestServer CreateServer(ITestOutputHelper log, out EndPo
         var server = CreateServer(log, out var targetEndpoint);
         var conn = await server.ConnectAsync(defaultOnly: true);
 
-        var target = server.AddEmptyNode(targetEndpoint);
-
-        // the target must be unaddressable by *every* form, not merely un-named. Hostnames are preferred and
+        // The target must be unaddressable by *every* form, not merely un-named. Hostnames are preferred and
         // it announces none, so the endpoint field is "?" - but the complement rule would then put its address
-        // in the metadata, and a topology refresh landing between here and the command would discover it there
-        // and route straight to it, leaving no redirect to test. Marking the address unknown as well removes
-        // that race by construction rather than relying on the refresh not happening: under RESP2 the
-        // subscription connection completing can trigger one, which is why this only ever failed on RESP2
-        server.SetAnnouncedAddress(target, AnnouncedAddress.Empty);
+        // in the metadata, and a topology refresh discovering it there would route straight to it, leaving no
+        // redirect to test. Under RESP2 the subscription connection completing can trigger such a refresh,
+        // which is why this only ever failed there.
+        //
+        // Announced at construction rather than set afterwards: setting it on the next line leaves the node
+        // visible, briefly, still announcing an address - a window a refresh landing at the wrong moment can
+        // see. That was the remaining flake.
+        var target = server.AddEmptyNode(targetEndpoint, AnnouncedAddress.Empty);
 
         server.Migrate((RedisKey)Key, target);
         return (conn, server);
 
@@ -299,11 +299,42 @@ public enum NodeFlags
         /// existing key, so it cannot produce a node whose identity form differs from its peers'.
         /// </summary>
         public EndPoint AddEmptyNode(EndPoint endpoint, NodeFlags flags = NodeFlags.None)
+            => AddEmptyNodeCore(endpoint, flags, announced: null);
+
+        /// <summary>
+        /// Add an empty node, fixing what it announces as its own address before it becomes visible.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// Setting this afterwards, via <see cref="SetAnnouncedAddress"/>, leaves a window in which a topology
+        /// read can observe the node still announcing an address - which is enough to make a client route
+        /// straight to it rather than take the redirect a test was trying to provoke.
+        /// </para>
+        /// <para>
+        /// A <see cref="DnsEndPoint"/> takes a name-only identity, which cannot also announce an address;
+        /// asking for one throws rather than quietly ignoring the argument.
+        /// </para>
+        /// </remarks>
+        public EndPoint AddEmptyNode(EndPoint endpoint, AnnouncedAddress announced, NodeFlags flags = NodeFlags.None)
+            => AddEmptyNodeCore(endpoint, flags, announced);
+
+        private EndPoint AddEmptyNodeCore(EndPoint endpoint, NodeFlags flags, AnnouncedAddress? announced)
         {
             if (endpoint is null) throw new ArgumentNullException(nameof(endpoint));
+            if (announced is { } requested && requested != AnnouncedAddress.Empty && endpoint is DnsEndPoint)
+            {
+                // ApplyNameOnlyIdentity below would overwrite it; refuse the contradiction rather than
+                // silently doing something else
+                throw new ArgumentException(
+                    $"A name-only node cannot announce {requested}: {Format.ToString(endpoint)}", nameof(announced));
+            }
+
             var node = new Node(this, endpoint, flags);
+            if (announced is { } value) node.Announced = value;
             node.UpdateSlots([]); // explicit empty range (rather than implicit "all nodes")
             ApplyNameOnlyIdentity(endpoint, node);
+
+            // published last, so nothing above is observable in a half-configured state
             if (!_nodes.TryAdd(endpoint, node))
             {
                 throw new ArgumentException($"Node already exists: {Format.ToString(endpoint)}", nameof(endpoint));
Original file line number	Diff line number	Diff line change
`@@ -76,8 +76,11 @@ public async Task CountKeys()`
`76`	`76`	`Skip.IfMissingDatabase(conn, db1Id);`
`77`	`77`	`Skip.IfMissingDatabase(conn, db2Id);`
`78`	`78`	`var server = GetAnyPrimary(conn);`
`79`		`- server.FlushDatabase(db1Id, CommandFlags.FireAndForget);`
`80`		`- server.FlushDatabase(db2Id, CommandFlags.FireAndForget);`
	`79`	`+`
	`80`	`+ // awaited, not fire-and-forget: the writes below happen on a different connection, so nothing`
	`81`	`+ // orders them against these flushes, and an unlucky run counts the leftovers too`
	`82`	`+ await server.FlushDatabaseAsync(db1Id);`
	`83`	`+ await server.FlushDatabaseAsync(db2Id);`
`81`	`84`	`}`
`82`	`85`	`await using (var conn = Create(defaultDatabase: db2Id))`
`83`	`86`	`{`