migrate Fsync tests

Sources/MongoDBTests/Main.swift

@@ -8,13 +8,11 @@ enum Main:TestMain
     static
     let all:[any TestBattery.Type] =
     [
-        Fsync               <ReplicatedConfiguration>.self,
         Indexes             <ReplicatedConfiguration>.self,
 
         Transactions        <ReplicatedConfiguration>.self,
 
 
-        Fsync               <SingleConfiguration>.self,
         Indexes             <SingleConfiguration>.self,
     ]
 }

Sources/MongoDBTests2/Cursors.swift

@@ -1,12 +1,7 @@
 import MongoDB
 import Testing
 
-extension Tag
-{
-    @Tag static var cursors:Self
-}
-
-@Suite(.tags(.cursors))
+@Suite
 struct Cursors
 {
     let collection:Mongo.Collection = "Ordinals"

Sources/MongoDBTests2/Fsync.swift

@@ -0,0 +1,40 @@
+import MongoDB
+import Testing
+
+@Suite
+struct Fsync
+{
+    @Test(arguments: [.single, .replicated] as [any Mongo.TestConfiguration])
+    func fsync(_ configuration:any Mongo.TestConfiguration) async throws
+    {
+        let bootstrap:Mongo.DriverBootstrap = configuration.bootstrap(on: .singleton)
+        try await bootstrap.withSessionPool(logger: .init(level: .error))
+        {
+            try await self.run(with: $0)
+        }
+    }
+
+    func run(with pool:Mongo.SessionPool) async throws
+    {
+        //  We should ensure we are locking and unlocking the same node!
+        let node:Mongo.ReadPreference = .nearest(tagSets: [["name": "A"]])
+
+        var lock:Mongo.FsyncLock
+
+        lock = try await pool.run(command: Mongo.Fsync.init(lock: true),
+            against: .admin,
+            on: node)
+
+        #expect(lock.count == 1)
+
+        //  We should always be able to run the ping command, even if the
+        //  node is write-locked.
+        try await pool.run(command: Mongo.Ping.init(), against: .admin, on: node)
+
+        lock = try await pool.run(command: Mongo.FsyncUnlock.init(),
+            against: .admin,
+            on: node)
+
+        #expect(lock.count == 0)
+    }
+}