CSHARP-5930: Update replica-set discovery and reporting in tests (#1974)

See CSHARP-6008 for details about why this change is needed.

There were multiple iterations getting to this point:

## Iteration 1

RequireServer.cs
- ClusterType()/ClusterTypes(): Now use GetActualClusterType() which maps a directConnect RS member to ClusterType.ReplicaSet (instead of the misleading Standalone)
- topology/topologies case: Uses actual server type — single matches only Standalone, replicaset matches IsReplicaSetMember()

DriverTestConfiguration.cs
- IsReplicaSet(): Checks server.Type.IsReplicaSetMember() instead of cluster.Description.Type == ClusterType.ReplicaSet, so a directConnect RS is correctly identified

ReadPreferenceOnStandaloneTests.cs (from earlier)
- Uses ServerType.Standalone instead of ClusterType.Standalone to decide whether $readPreference is expected

ServerDiscoveryProseTests.cs
- Missing secondary now throws SkipException instead of a plain Exception

UnifiedTestSpecRunner.cs
- Added IsDirectConnectionToReplicaSet() helper
- ServerDiscoveryAndMonitoring: Skips logging-replicaset.json, replicaset-emit-topology-changed-before-close.json, rediscover-quickly-after-step-down.json when on directConnect RS (these require full multi-server topology discovery events)
- ServerSelection: Skips replica-set.json when on directConnect RS (same reason)

## Iteration 2

- Root cause: My GetActualClusterType() change made RequireServer.ClusterType(ClusterType.ReplicaSet) pass for a directConnect RSPrimary. This caused Connection_pool_should_not_be_cleared_when_replSetStepDown_and_GetMore to run — a test that was previously always skipped on this setup. That test calls { replSetStepDown: 30, force: true }, which makes the single-node RS step down and refuse writes for up to 30 seconds. All subsequent write operations in other tests (like DropCollection in fixture setup) then fail with MongoNotPrimaryException.
- Fix: Added RequireServer.ReplicaSetDataBearingMembers(int minimum) — a new check that counts how many data-bearing RS members the cluster has

## Iteration 3

- Applied .ReplicaSetDataBearingMembers(2) to Connection_pool_should_not_be_cleared_when_replSetStepDown_and_GetMore — the step-down test only makes sense (and is safe) with at least 2 RS members so a new primary can be elected after the step-down

## Iteration 4

- CausalConsistencyExamples.cs — Causal_Consistency_Example_3: Replaced the hardcoded "mongodb://localhost/?readPreference=secondaryPreferred" with settings built from CoreTestConfiguration.ConnectionString plus ReadPreference.SecondaryPreferred. The example intent is preserved.
- ClientSideEncryption2Examples.cs — FLE2AutomaticEncryption: Added an explicit skip when CRYPT_SHARED_LIB_PATH is not set (CSFLE/auto-encryption requires it), and fixed two new MongoClient() calls to use CoreTestConfiguration.ConnectionString.ToString() instead of the default localhost:27017.

Fix replica-set detection in tests to handle both directConnection=true and a normal connection to a single node replica set.

- Renamed IsDirectConnectionToReplicaSet() → IsSingleNodeReplicaSet() — better reflects that it covers both connection modes.
- Updated the logic: the old method required description.DirectConnection == true. The new method checks servers.Count == 1 && servers[0].Type.IsReplicaSetMember(), which is true for both:
 - directConnection=true to a RS member (old case)
 - replicaSet=rs0 on a single-node RS (new case)
- Updated both call sites in ServerDiscoveryAndMonitoring and ServerSelection with updated comments.

Update Causal_Consistency_Example_2 to skip because it needs two nodes

CSHARP-5930: Address review feedback on replica-set topology helpers

- GetActualClusterType: add SpinWait (10 s) in the DirectConnection path so
  the server type is known before reading it, avoiding spurious Unknown
  results on a fresh cluster. Throws InvalidOperationException if the
  timeout expires, matching the pattern in DriverTestConfiguration.IsReplicaSet.

- IsRequirementSatisfied "topologies"/"topology" case: same SpinWait before
  reading the server type from the cluster description.

- SkipNotSupportedTestCases: add optional `reason` parameter so callers can
  supply a specific message instead of the generic "not supported" text.

- Single-node RS skips in UnifiedTestSpecRunner now emit messages that
  explicitly mention "single-node replica set" for searchable CI logs
  ("does not produce full RS topology discovery events" / "does not have a
  secondary").

CSHARP-5930: Address second-round review feedback

- GetActualClusterType: replace InvalidOperationException with SkipException
  on spin-wait timeout, consistent with every other Require* helper that
  signals a skip rather than a hard failure when the topology is not as
  expected.

- SkipNotSupportedTestCases: use StartsWith(operationName + ":") when
  operationName ends in ".json" so that a similarly-named spec file (e.g.
  "other-logging-replicaset.json") cannot accidentally match.  Non-filename
  matches continue to use Contains as before.

- ServerDiscoveryProseTests: add ReplicaSetDataBearingMembers(2) to the
  RequireServer chain so single-node RS is skipped at the require level.
  The secondary-not-found check below it is now a hard failure, because the
  require guard means we must be on a multi-node RS where a secondary is
  expected.

CSHARP-5930: Address third-round review feedback

- UnifiedTestSpecRunner: add CSHARP-6008 references to the single-node RS
  skip-block comments so the skips are auditable and findable.

- UnifiedTestSpecRunner: split the dual-mode SkipNotSupportedTestCases into
  two clearly-named helpers: SkipFile (StartsWith match on filename, always
  requires an explicit reason) and SkipNotSupportedTestCases (Contains match
  on description substring, unchanged callers).

- RequireServer.GetActualClusterType: add a one-line comment explaining why
  the non-direct-connection path reads Description.Type without a spin-wait.

- RequireServer.IsTopologyMatch: add comment confirming that matching any
  IsReplicaSetMember() for "replicaset" is intentional per unified-spec
  semantics (Primary / Secondary / Arbiter / Other / Ghost all qualify).

- DriverTestConfiguration.IsReplicaSet: add comment noting the broad RS-
  member match and directing callers that need a data-bearing member to use
  GetReplicaSetNumberOfDataBearingMembers instead.

More review feedback

[review-iter 1] Address review findings

[review-iter 2] Address review findings

[review-iter 3] Address review findings

[review-iter 4] Address review findings

[review-iter 5] Address review findings

[review-iter 5] Address review findings

Minor Copilot feedback

- Copilot's concern is valid: if the spin times out, cluster.Description.Servers would likely be empty or all-Unknown, the factory would return false, and the Lazy<bool> would cache that false for the rest of the process — silently un-skipping logging-replicaset.json, replicaset-emit-topology-changed-before-close.json, rediscover-quickly-after-step-down.json, and replica-set.json on real single-node RS environments.
  - The fix captures the SpinWait.SpinUntil return and throws SkipException with the cluster description on timeout, mirroring the precedent in RequireServer.GetActualClusterType() at RequireServer.cs:325-328. The Lazy then caches the exception, so all subsequent calls in a broken-cluster process throw the same skip rather than spinning another 10s each.
- Fix at RequireServer.cs:256-263: short-circuits when cluster.Description.DirectConnection && minimum > 1 so each affected test skips instantly instead of paying a 10-second timeout. The original directConnection comment is reworded into the new short-circuit branch.
- Summary: ReplicaSetDataBearingMembers now no-ops on non-RS topologies instead of throwing. Effect on the three callers:
  - ConnectionsSurvivePrimaryStepDownTests.cs:80 — unchanged (already gated by .ClusterType(ReplicaSet)).
  - ServerDiscoveryProseTests.cs:55 — unchanged (already gated by .ClusterTypes(ReplicaSet)).
  - CausalConsistencyExamples.cs:78 — now correctly runs on Sharded (where mongos handles per-shard secondary routing for ReadPreference.Secondary) while still skipping on single-node RS.
-  Three changes in ServerDiscoveryProseTests.cs:62-77:
  1. Wait on the right predicate: spin on Any(s => Connected && ReplicaSetSecondary) instead of ClusterState.Connected. The old check was satisfied by the primary alone and never actually waited for a secondary.
  2. Longer timeout: 3s → 10s, matching the other SDAM spins in the codebase, reducing the slow-environment flakiness Copilot flagged.
  3. Richer diagnostic: include clusterDescription in the failure message, so when this branch does fire it points at the real culprit (likely ReplicaSetDataBearingMembers undercounting).
  - Kept Exception rather than SkipException per the iter 2 reviewer's intent — added an inline comment so a future reader doesn't try to re-skip it. The stale "this case should be skipped" line in my old commit message was just out-of-date; iter 2 explicitly reverted that.

CSHARP-5930: Address review feedback on replica-set topology helpers

Consolidate the replica-set topology helpers into DriverTestConfiguration
and remove fragile waits, per PR review.

TL;DR
- ReplicaSetDataBearingMembers now reuses
  DriverTestConfiguration.GetReplicaSetNumberOfDataBearingMembers, so it
  waits for the cluster to connect and then counts instead of spinning
  the full 10s when the required count can never be reached.
- GetActualClusterType moved to DriverTestConfiguration and now throws
  InvalidOperationException (fail, not skip) when the cluster type cannot
  be determined.
- Single-node-RS detection moved to
  DriverTestConfiguration.IsSingleNodeReplicaSet.
- SkipFile identifies a test case's source spec file from the
  discoverer's "_fileName" value rather than parsing the composite
  test-case name.

Details

ReplicaSetDataBearingMembers (RequireServer):
The previous implementation special-cased directConnection and then
spun on `Servers.Count(IsDataBearing) >= minimum`, which always ran to
the full timeout whenever the cluster simply did not have `minimum`
data-bearing members (e.g. requiring 3 on a 2-member set, or any
multi-member requirement under directConnection). It now delegates to
DriverTestConfiguration.GetReplicaSetNumberOfDataBearingMembers, which
waits for all servers to connect and returns the real count; the method
then compares once and skips immediately. The directConnection case
needs no special handling: a direct connection only ever sees its single
server, so the count tops out at 1 and the comparison skips at once.

GetActualClusterType moved to DriverTestConfiguration:
The effective-cluster-type logic (mapping a directConnection server type
to its real cluster type, with a short spin for early-startup races) now
lives alongside the other cluster helpers in DriverTestConfiguration as
an internal static taking the cluster. RequireServer keeps a thin
delegating wrapper so its call sites are unchanged. When the type cannot
be determined it now throws InvalidOperationException rather than
SkipException, matching the existing IsReplicaSet/WaitForAllServersToBe-
Connected convention: an undeterminable topology is an environment
failure that should fail the test, not silently skip it.

IsSingleNodeReplicaSet moved to DriverTestConfiguration:
The single-node-RS detection used by the unified spec runner now lives
in DriverTestConfiguration and builds on the existing IsReplicaSet spin
(which throws if the type never resolves). The runner's process-lifetime
Lazy cache is dropped; once the cluster is connected the answer is
stable and the underlying spin returns immediately, so the cache added
no value.

SkipFile uses the discoverer's _fileName:
UnifiedTestsDiscoverer already stamps each test case's shared document
with "_fileName". SkipFile now matches on that value instead of
StartsWith-parsing the composite "<file>:<description>" test-case name.
The embedded-resource typo guard is retained so a misspelled file name
throws loudly instead of silently skipping nothing.

CSHARP-5930: Remove SkipFile embedded-resource typo guard

SkipFile previously validated its fileName argument against an
assembly-wide scan of embedded .json resources (the
__embeddedJsonSpecResources Lazy) so a typo threw a precise error
instead of silently skipping nothing.

Now that SkipFile matches on the discoverer's "_fileName" value, drop
the guard and the Lazy entirely. SkipFile only runs inside
IsSingleNodeReplicaSet() blocks, so a mistyped fileName degrades to the
file's tests running on single-node RS - the exact topology they are
skipped for - which surfaces as a normal test failure rather than a
silent pass. The reflection scan and ~18 lines of guard are not worth
that marginally more precise diagnostic.

Feedback.

Author: ajcvickers

tests/MongoDB.Driver.Examples/CausalConsistencyExamples.cs

@@ -75,7 +75,7 @@ public void Causal_Consistency_Example_1()
         [Fact]
         public void Causal_Consistency_Example_2()
         {
-            RequireServer.Check().SupportsCausalConsistency();
+            RequireServer.Check().SupportsCausalConsistency().ReplicaSetDataBearingMembers(2);
 
             string testDatabaseName = "test";
             string itemsCollectionName = "items";
@@ -120,9 +120,10 @@ public void Causal_Consistency_Example_3()
             DropCollection(CreateClient(), "myDatabase", "myCollection");
 
             // Start Tunable Consistency Controls Example
-            var connectionString = "mongodb://localhost/?readPreference=secondaryPreferred";
+            var settings = MongoClientSettings.FromConnectionString(CoreTestConfiguration.ConnectionString.ToString());
+            settings.ReadPreference = ReadPreference.SecondaryPreferred;
 
-            var client = new MongoClient(connectionString);
+            var client = new MongoClient(settings);
             var database = client.GetDatabase("myDatabase");
             var collection = database.GetCollection<BsonDocument>("myCollection");
 

tests/MongoDB.Driver.Examples/ClientSideEncryption2Examples.cs

@@ -38,6 +38,10 @@ public class ClientSideEncryption2Examples
         public void FLE2AutomaticEncryption()
         {
             RequireServer.Check().Supports(Feature.Csfle2).ClusterTypes(ClusterType.ReplicaSet, ClusterType.Sharded, ClusterType.LoadBalanced);
+            if (string.IsNullOrWhiteSpace(CoreTestConfiguration.GetCryptSharedLibPath()))
+            {
+                throw new Xunit.Sdk.SkipException("Test skipped because CRYPT_SHARED_LIB_PATH is not set.");
+            }
 
             var unencryptedClient = DriverTestConfiguration.Client;
 
@@ -52,7 +56,7 @@ public void FLE2AutomaticEncryption()
             };
             kmsProviders.Add("local", localKey);
 
-            var keyVaultClient = new MongoClient();
+            var keyVaultClient = new MongoClient(CoreTestConfiguration.ConnectionString.ToString());
 
             // Create two data keys.
             var clientEncryptionOptions = new ClientEncryptionOptions(keyVaultClient, KeyVaultNamespace, kmsProviders);
@@ -92,7 +96,9 @@ public void FLE2AutomaticEncryption()
             };
 
             var autoEncryptionOptions = new AutoEncryptionOptions(KeyVaultNamespace, kmsProviders, encryptedFieldsMap: encryptedFieldsMap);
-            var encryptedClient = new MongoClient(new MongoClientSettings { AutoEncryptionOptions = autoEncryptionOptions });
+            var encryptedClientSettings = MongoClientSettings.FromConnectionString(CoreTestConfiguration.ConnectionString.ToString());
+            encryptedClientSettings.AutoEncryptionOptions = autoEncryptionOptions;
+            var encryptedClient = new MongoClient(encryptedClientSettings);
 
             // Create an FLE 2 collection.
             var database = encryptedClient.GetDatabase(CollectionNamespace.DatabaseNamespace.DatabaseName);

tests/MongoDB.Driver.TestHelpers/Core/XunitExtensions/RequireServer.cs

@@ -19,7 +19,9 @@
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Encryption;
+using MongoDB.Driver.Tests;
 using Xunit.Sdk;
+using ClusterTypeEnum = MongoDB.Driver.Core.Clusters.ClusterType;
 
 namespace MongoDB.Driver.Core.TestHelpers.XunitExtensions
 {
@@ -67,7 +69,7 @@ internal RequireServer Cluster(Func<IClusterInternal, bool> condition, string be
 
         public RequireServer ClusterType(ClusterType clusterType)
         {
-            var actualClusterType = CoreTestConfiguration.Cluster.Description.Type;
+            var actualClusterType = GetActualClusterType();
             if (actualClusterType == clusterType)
             {
                 return this;
@@ -77,7 +79,7 @@ public RequireServer ClusterType(ClusterType clusterType)
 
         public RequireServer ClusterTypes(params ClusterType[] clusterTypes)
         {
-            var actualClusterType = CoreTestConfiguration.Cluster.Description.Type;
+            var actualClusterType = GetActualClusterType();
             if (clusterTypes.Contains(actualClusterType))
             {
                 return this;
@@ -172,13 +174,13 @@ public RequireServer Supports(params Feature[] features)
 
         public RequireServer SupportsCausalConsistency()
         {
-            return ClusterTypes(Clusters.ClusterType.Sharded, Clusters.ClusterType.ReplicaSet).SupportsSessions();
+            return ClusterTypes(ClusterTypeEnum.Sharded, ClusterTypeEnum.ReplicaSet).SupportsSessions();
         }
 
         public RequireServer SupportsSessions()
         {
             var clusterDescription = CoreTestConfiguration.Cluster.Description;
-            if (clusterDescription.LogicalSessionTimeout != null || clusterDescription.Type == Clusters.ClusterType.LoadBalanced)
+            if (clusterDescription.LogicalSessionTimeout != null || GetActualClusterType() == ClusterTypeEnum.LoadBalanced)
             {
                 return this;
             }
@@ -220,8 +222,8 @@ public RequireServer Tls(bool required = true)
 
         public RequireServer MultipleMongosesIfSharded(bool required)
         {
-            var clusterType = CoreTestConfiguration.Cluster.Description.Type;
-            if (clusterType == Clusters.ClusterType.Sharded || clusterType == Clusters.ClusterType.LoadBalanced)
+            var clusterType = GetActualClusterType();
+            if (clusterType == ClusterTypeEnum.Sharded || clusterType == ClusterTypeEnum.LoadBalanced)
             {
                 MultipleMongoses(required);
             }
@@ -239,6 +241,31 @@ public RequireServer MultipleMongoses(bool required)
             throw new SkipException($"Test skipped because the cluster does not have multiple mongoses.");
         }
 
+        public RequireServer ReplicaSetDataBearingMembers(int minimum)
+        {
+            // Only meaningful on replica-set topologies; on sharded/standalone/load-balanced the
+            // "data-bearing members" concept doesn't translate to a useful constraint. No-op on
+            // non-RS so callers can chain this onto a multi-topology allowlist (e.g. after
+            // SupportsCausalConsistency, which permits RS or Sharded) without inadvertently
+            // skipping sharded runs. Callers who want RS-only must chain ClusterType(ReplicaSet)
+            // explicitly.
+            if (GetActualClusterType() != ClusterTypeEnum.ReplicaSet)
+            {
+                return this;
+            }
+            // GetReplicaSetNumberOfDataBearingMembers waits for the cluster to connect and then
+            // counts, so it returns promptly with the real count rather than spinning the full
+            // timeout when the count can never reach `minimum` (e.g. a directConnection only ever
+            // sees its single targeted server, so the count tops out at 1).
+            var cluster = CoreTestConfiguration.Cluster;
+            var actualCount = DriverTestConfiguration.GetReplicaSetNumberOfDataBearingMembers(cluster);
+            if (actualCount >= minimum)
+            {
+                return this;
+            }
+            throw new SkipException($"Test skipped because replica set has {actualCount} data-bearing member(s) and at least {minimum} are required: {cluster.Description}.");
+        }
+
         public RequireServer VersionGreaterThanOrEqualTo(SemanticVersion version)
         {
             var actualVersion = CoreTestConfiguration.ServerVersion;
@@ -285,6 +312,8 @@ public RequireServer VersionLessThanOrEqualTo(string version)
         }
 
         // private methods
+        private ClusterType GetActualClusterType() => DriverTestConfiguration.GetActualClusterType(CoreTestConfiguration.Cluster);
+
         private bool CanRunOn(BsonDocument requirements)
         {
             return requirements.All(IsRequirementSatisfied);
@@ -335,9 +364,10 @@ private bool IsRequirementSatisfied(BsonElement requirement)
                     return true;
                 case "topologies":
                 case "topology":
-                    var actualClusterType = CoreTestConfiguration.Cluster.Description.Type;
-                    var runOnClusterTypes = requirement.Value.AsBsonArray.Select(topology => MapTopologyToClusterType(topology.AsString)).ToList();
-                    return runOnClusterTypes.Contains(actualClusterType);
+                    {
+                        var actualClusterType = GetActualClusterType();
+                        return requirement.Value.AsBsonArray.Any(topology => IsTopologyMatch(topology.AsString, actualClusterType));
+                    }
                 case "csfle":
                     return IsCsfleRequirementSatisfied(requirement);
                 default:
@@ -359,15 +389,15 @@ private bool IsCsfleRequirementSatisfied(BsonElement requirement)
             return SemanticVersionCompareToAsReleased(actualLibmongocryptVersion, minLibmongocryptVersion) >= 0;
         }
 
-        private ClusterType MapTopologyToClusterType(string topology)
+        private bool IsTopologyMatch(string topology, ClusterTypeEnum clusterType)
         {
             switch (topology)
             {
-                case "single": return Clusters.ClusterType.Standalone;
-                case "replicaset": return Clusters.ClusterType.ReplicaSet;
+                case "single": return clusterType == ClusterTypeEnum.Standalone;
+                case "replicaset": return clusterType == ClusterTypeEnum.ReplicaSet;
                 case "sharded-replicaset":
-                case "sharded": return Clusters.ClusterType.Sharded;
-                case "load-balanced": return Clusters.ClusterType.LoadBalanced;
+                case "sharded": return clusterType == ClusterTypeEnum.Sharded;
+                case "load-balanced": return clusterType == ClusterTypeEnum.LoadBalanced;
                 default: throw new ArgumentException($"Invalid topology: \"{topology}\".", nameof(topology));
             }
         }

tests/MongoDB.Driver.TestHelpers/DriverTestConfiguration.cs

@@ -223,14 +223,19 @@ public static ExpressionTranslationOptions GetTranslationOptions()
             };
         }
 
+        // Returns true if any server reports an RS member type (Primary, Secondary, Arbiter,
+        // Other, or Ghost). Callers that need specifically a data-bearing member should use
+        // GetReplicaSetNumberOfDataBearingMembers instead.
         internal static bool IsReplicaSet(IClusterInternal cluster)
         {
-            var clusterTypeIsKnown = SpinWait.SpinUntil(() => cluster.Description.Type != ClusterType.Unknown, TimeSpan.FromSeconds(10));
-            if (!clusterTypeIsKnown)
+            var serverIsKnown = SpinWait.SpinUntil(
+                () => cluster.Description.Servers.Any(s => s.Type != ServerType.Unknown),
+                TimeSpan.FromSeconds(10));
+            if (!serverIsKnown)
             {
                 throw new InvalidOperationException($"Unable to determine cluster type: {cluster.Description}.");
             }
-            return cluster.Description.Type == ClusterType.ReplicaSet;
+            return cluster.Description.Servers.Any(s => s.Type.IsReplicaSetMember());
         }
 
         internal static int GetReplicaSetNumberOfDataBearingMembers(IClusterInternal cluster)
@@ -241,9 +246,58 @@ internal static int GetReplicaSetNumberOfDataBearingMembers(IClusterInternal clu
             }
 
             WaitForAllServersToBeConnected(cluster);
+            // Under a directConnect the description only includes the single node being targeted,
+            // so this count reflects only that server. RequireServer.ReplicaSetDataBearingMembers(2)
+            // therefore correctly skips tests that need multiple members when connected directly.
             return cluster.Description.Servers.Count(s => s.IsDataBearing);
         }
 
+        // Returns the effective cluster type. For direct connections Description.Type is always
+        // Standalone regardless of the actual server type, so the server's reported type is used
+        // instead. Throws (rather than skips) if the type cannot be determined: an undeterminable
+        // topology is an environment failure, not a "this topology isn't applicable" skip.
+        internal static ClusterType GetActualClusterType(IClusterInternal cluster)
+        {
+            var description = cluster.Description;
+            if (description.DirectConnection)
+            {
+                var serverIsKnown = SpinWait.SpinUntil(
+                    () => cluster.Description.Servers.Any(s => s.Type != ServerType.Unknown),
+                    TimeSpan.FromSeconds(10));
+                if (!serverIsKnown)
+                {
+                    throw new InvalidOperationException($"Unable to determine cluster type: {cluster.Description}.");
+                }
+                return cluster.Description.Servers.First(s => s.Type != ServerType.Unknown).Type.ToClusterType();
+            }
+            // For non-direct connections the cluster machinery resolves Description.Type before tests
+            // run, but spin briefly here as well so early-startup invocations don't race against the
+            // initial SDAM rounds.
+            var typeIsKnown = SpinWait.SpinUntil(
+                () => cluster.Description.Type != ClusterType.Unknown,
+                TimeSpan.FromSeconds(10));
+            if (!typeIsKnown)
+            {
+                throw new InvalidOperationException($"Unable to determine cluster type: {cluster.Description}.");
+            }
+            return cluster.Description.Type;
+        }
+
+        internal static bool IsSingleNodeReplicaSet(IClusterInternal cluster)
+        {
+            // IsReplicaSet spins until at least one server type is known (throwing if it never
+            // resolves), so a transient empty / all-Unknown snapshot is never mistaken for "not a
+            // replica set".
+            if (!IsReplicaSet(cluster))
+            {
+                return false;
+            }
+            // Matches both a directConnection to a single RS member and a non-directConnection
+            // single-node RS.
+            var servers = cluster.Description.Servers;
+            return servers.Count == 1 && servers[0].Type.IsReplicaSetMember();
+        }
+
         internal static void WaitForAllServersToBeConnected(IClusterInternal cluster)
         {
             var allServersAreConnected = SpinWait.SpinUntil(() => cluster.Description.Servers.All(s => s.State == ServerState.Connected), TimeSpan.FromSeconds(10));

tests/MongoDB.Driver.Tests/ConnectionsSurvivePrimaryStepDownTests.cs

@@ -76,7 +76,7 @@ public void Connection_pool_should_be_cleared_when_Shutdown_exceptions(
         [ParameterAttributeData]
         public void Connection_pool_should_not_be_cleared_when_replSetStepDown_and_GetMore([Values(false, true)] bool async)
         {
-            RequireServer.Check().ClusterType(ClusterType.ReplicaSet);
+            RequireServer.Check().ClusterType(ClusterType.ReplicaSet).ReplicaSetDataBearingMembers(2);
 
             var eventCapturer = new EventCapturer().Capture<ConnectionPoolClearedEvent>();
             using (var client = CreateMongoClient(eventCapturer))

tests/MongoDB.Driver.Tests/Specifications/UnifiedTestSpecRunner.cs

@@ -15,6 +15,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using FluentAssertions;
 using MongoDB.Bson.TestHelpers.JsonDrivenTests;
 using MongoDB.Driver.Core.Clusters;
@@ -210,11 +211,34 @@ public void RetryableWrites(JsonDrivenTestCase testCase)
         [Category("SDAM", "SupportLoadBalancing")]
         [UnifiedTestsTheory("server_discovery_and_monitoring.tests.unified")]
         public void ServerDiscoveryAndMonitoring(JsonDrivenTestCase testCase)
-            => Run(testCase, IsSdamLogValid, new SdamRunnerEventsProcessor(testCase.Name));
+        {
+            // These tests require full RS topology discovery (multiple topology change events).
+            // A single-node RS (whether via directConnect or replicaSet= with one member) only fires 2 topology
+            // events, never the full RS discovery sequence with secondary discovery. CSHARP-6008.
+            if (IsSingleNodeReplicaSet())
+            {
+                const string singleNodeRsReason = "Test skipped because single-node replica set does not produce full RS topology discovery events (CSHARP-6008).";
+                SkipFile(testCase, "logging-replicaset.json", singleNodeRsReason);
+                SkipFile(testCase, "replicaset-emit-topology-changed-before-close.json", singleNodeRsReason);
+                SkipFile(testCase, "rediscover-quickly-after-step-down.json", singleNodeRsReason);
+            }
+
+            Run(testCase, IsSdamLogValid, new SdamRunnerEventsProcessor(testCase.Name));
+        }
 
         [Category("SupportLoadBalancing")]
         [UnifiedTestsTheory("server_selection.tests.logging")]
-        public void ServerSelection(JsonDrivenTestCase testCase) => Run(testCase);
+        public void ServerSelection(JsonDrivenTestCase testCase)
+        {
+            // replica-set.json expects full RS topology discovery events and a secondary, not available on a
+            // single-node RS (whether via directConnect or replicaSet= with one member). CSHARP-6008.
+            if (IsSingleNodeReplicaSet())
+            {
+                SkipFile(testCase, "replica-set.json", "Test skipped because single-node replica set does not have a secondary (CSHARP-6008).");
+            }
+
+            Run(testCase);
+        }
 
         [UnifiedTestsTheory("sessions.tests")]
         public void Sessions(JsonDrivenTestCase testCase) => Run(testCase);
@@ -277,6 +301,25 @@ private void Run(JsonDrivenTestCase testCase, Predicate<LogEntry> loggingFilter
         private static void RequireKmsMock() =>
             RequireEnvironment.Check().EnvironmentVariable("KMS_MOCK_SERVERS_ENABLED");
 
+        private static bool IsSingleNodeReplicaSet() => DriverTestConfiguration.IsSingleNodeReplicaSet(CoreTestConfiguration.Cluster);
+
+
+        /// <summary>
+        /// Skip all tests sourced from a specific JSON spec file. The source file is identified via
+        /// the "_fileName" value the discoverer stamps onto every test case (see
+        /// UnifiedTestsDiscoverer), rather than by parsing the composite test-case name.
+        /// </summary>
+        private static void SkipFile(JsonDrivenTestCase testCase, string fileName, string reason)
+        {
+            if (testCase.Shared.GetValue("_fileName", null)?.AsString == fileName)
+            {
+                throw new SkipException(reason);
+            }
+        }
+
+        /// <summary>
+        /// Skip tests whose name contains the given operation substring.
+        /// </summary>
         private static void SkipNotSupportedTestCases(JsonDrivenTestCase testCase, string operationName)
         {
             if (testCase.Name.Contains(operationName))
@@ -285,7 +328,9 @@ private static void SkipNotSupportedTestCases(JsonDrivenTestCase testCase, strin
             }
         }
 
-        // used by SkippedTestsProvider property in UnifiedTests attribute.
+        /// <summary>
+        /// Used by SkippedTestsProvider property in UnifiedTests attribute.
+        /// </summary>
         private static readonly HashSet<string> __ignoredTests = new(
         [
             // CMAP