Refactor test cleanup to properly handle async shutdown operations

- Add dedicated async and background shutdown helper functions
- Replace defer blocks with InBackground variants for fire-and-forget cleanup
- Use explicit await for async shutdown in MemoryAdapterAsyncTests
- Prevents test hanging issues by properly managing EventLoopGroup and NIOThreadPool lifecycle

Author: zamderax

Tests/CasbinTests/ConfigTests.swift

@@ -9,9 +9,9 @@ struct ConfigTests {
         let filePath = #file.components(separatedBy: "ConfigTests.swift")[0] + "examples/testini.ini"
         let pool = NIOThreadPool(numberOfThreads: 1)
         pool.start()
-        defer { shutdownThreadPoolAsync(pool) }
+        defer { shutdownThreadPoolInBackground(pool) }
         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        defer { shutdownEventLoopGroupAsync(elg) }
+        defer { shutdownEventLoopGroupInBackground(elg) }
         let fileIo = NonBlockingFileIO(threadPool: pool)
 
         var config = try Config.from(file: filePath, fileIo: fileIo, on: elg.next()).wait()
@@ -36,7 +36,7 @@ struct ConfigTests {
     @Test("load from text and get/set")
     func testFromText() throws {
         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        defer { shutdownEventLoopGroupAsync(elg) }
+        defer { shutdownEventLoopGroupInBackground(elg) }
         let text = #"""
             # test config
                             debug = true

Tests/CasbinTests/EnforcerTests.swift

@@ -12,8 +12,8 @@ struct EnforcerTests {
         pool.start()
         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         defer {
-            shutdownEventLoopGroupAsync(elg)
-            shutdownThreadPoolAsync(pool)
+            shutdownEventLoopGroupInBackground(elg)
+            shutdownThreadPoolInBackground(pool)
         }
         return try body(pool, elg)
     }

Tests/CasbinTests/MemoryAdapterAsyncTests.swift

@@ -6,12 +6,18 @@ import NIO
 struct MemoryAdapterAsyncTests {
 
     // Each test must shut down its EventLoopGroup or swift test may hang.
-    // Provide a helper that manages lifecycle for us.
+    // Provide a helper that manages lifecycle and properly awaits shutdown completion.
     private func withAdapter<R>(_ body: (MemoryAdapter) async throws -> R) async throws -> R {
         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
-        defer { shutdownEventLoopGroupAsync(elg) }
         let adapter = MemoryAdapter(on: elg.next())
-        return try await body(adapter)
+        do {
+            let result = try await body(adapter)
+            try await shutdownEventLoopGroupAsync(elg)
+            return result
+        } catch {
+            try? await shutdownEventLoopGroupAsync(elg)
+            throw error
+        }
     }
 
     private func makeModel() -> DefaultModel {

Tests/CasbinTests/RbacApiTests.swift

@@ -9,8 +9,8 @@ struct RbacApiTests {
         pool.start()
         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         defer {
-            shutdownEventLoopGroupAsync(elg)
-            shutdownThreadPoolAsync(pool)
+            shutdownEventLoopGroupInBackground(elg)
+            shutdownThreadPoolInBackground(pool)
         }
         let fileIo = NonBlockingFileIO(threadPool: pool)
         let m = try DefaultModel.from(file: TestsfilePath + mfile, fileIo: fileIo, on: elg.next()).wait()

Tests/CasbinTests/TestSupport.swift

@@ -7,11 +7,41 @@ public let TestsfilePath = #file.components(separatedBy: "TestSupport.swift")[0]
 @inline(__always)
 func tryBool(_ body: () throws -> Bool) -> Bool { (try? body()) ?? false }
 
-// Non-blocking shutdown helpers so cooperative test executors don't hang.
-func shutdownEventLoopGroupAsync(_ group: EventLoopGroup) {
+// MARK: - Awaitable async shutdown helpers
+// Use these in async test contexts where you can await completion.
+
+func shutdownEventLoopGroupAsync(_ group: EventLoopGroup) async throws {
+    try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+        group.shutdownGracefully(queue: .global()) { error in
+            if let error = error {
+                continuation.resume(throwing: error)
+            } else {
+                continuation.resume()
+            }
+        }
+    }
+}
+
+func shutdownThreadPoolAsync(_ pool: NIOThreadPool) async throws {
+    try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+        pool.shutdownGracefully(queue: .global()) { error in
+            if let error = error {
+                continuation.resume(throwing: error)
+            } else {
+                continuation.resume()
+            }
+        }
+    }
+}
+
+// MARK: - Fire-and-forget background shutdown helpers
+// Use these in synchronous test contexts where blocking would cause hangs.
+// These initiate shutdown but return immediately without waiting for completion.
+
+func shutdownEventLoopGroupInBackground(_ group: EventLoopGroup) {
     group.shutdownGracefully(queue: .global()) { _ in }
 }
 
-func shutdownThreadPoolAsync(_ pool: NIOThreadPool) {
+func shutdownThreadPoolInBackground(_ pool: NIOThreadPool) {
     pool.shutdownGracefully(queue: .global()) { _ in }
 }