Fixed some naming issues with overridden functions.

Author: FoxClock

Tests/SQLClientSwiftTests/SQLClientSwiftTests.swift

@@ -3,49 +3,49 @@
 // Set environment variables: HOST, USERNAME, PASSWORD, DATABASE (optional)
 
 import XCTest
+
 @testable import SQLClientSwift
 
 final class SQLClientSwiftTests: XCTestCase {
 
     private func env(_ key: String) -> String { ProcessInfo.processInfo.environment[key] ?? "" }
-    private var host:     String { env("HOST") }
+    private var host: String { env("HOST") }
     private var username: String { env("USERNAME") }
     private var password: String { env("PASSWORD") }
     private var database: String { env("DATABASE") }
     private var canConnect: Bool { !host.isEmpty && !username.isEmpty && !password.isEmpty }
-    private var client: SQLClient!       // global client
+    private var client: SQLClient!  // global client
 
     private func makeClient() async throws -> SQLClient {
         let c = SQLClient()
-        try await c.connect(server: host, username: username, password: password,
-                                 database: database.isEmpty ? nil : database)
+        try await c.connect(
+            server: host, username: username, password: password,
+            database: database.isEmpty ? nil : database)
         return c
     }
-    
+
     /// Called before each XCTest method is run. Able to throw errors on setup.
-    /// Centralises boilerplate setup making 
-    override func setupWithError() throws {
-        try await super.setupWithError()
-        guard canConnect else {
-            throw XCTSkip("Set HOST, USERNAME, PASSWORD environment variables to run tests.")
-        }
+    /// Centralises boilerplate setup making
+    override func setUp() async throws {
+        try super.setUpWithError()
+
         client = try await makeClient()
     }
 
     /// Called after each XCTest method is run. Able to throw errors on cleanup.
     /// Ensures cleanup from each test is completed after the test is run. Before
     /// the next test is run.
-    override func tearDownWithError() throws {
+    override func tearDown() async throws {
         try await client.disconnect()
-        try await super.tearDownWithError()
+        try await super.tearDown()
     }
 
-
     func testConnect() async throws {
         // Use a local client, as the global client is already connected
         let localClient = SQLClient()
-        try await localClient.connect(server: host, username: username, password: password,
-                                 database: database.isEmpty ? nil : database)
+        try await localClient.connect(
+            server: host, username: username, password: password,
+            database: database.isEmpty ? nil : database)
 
         let connected = await localClient.isConnected
         XCTAssertTrue(connected)
@@ -58,15 +58,16 @@ final class SQLClientSwiftTests: XCTestCase {
     func testDoubleConnectThrows() async throws {
         // Use a local client as the global client is already connected
         let localClient = SQLClient()
-        try await localClient.connect(server: host, username: username, password: password,
-                                 database: database.isEmpty ? nil : database)
+        try await localClient.connect(
+            server: host, username: username, password: password,
+            database: database.isEmpty ? nil : database)
         // Defer is used here as race condition on cleanup is inconsequential
         defer { Task { await localClient.disconnect() } }
-        
+
         do {
             try await localClient.connect(server: host, username: username, password: password)
             XCTFail("Expected alreadyConnected")
-        } catch SQLClientError.alreadyConnected { }
+        } catch SQLClientError.alreadyConnected {}
     }
 
     func testSelectScalar() async throws {
@@ -114,11 +115,12 @@ final class SQLClientSwiftTests: XCTestCase {
     }
 
     func testRowsAffected() async throws {
-        try await client.run("""
-            IF OBJECT_ID('tempdb..#T') IS NOT NULL DROP TABLE #T;
-            CREATE TABLE #T (id INT);
-            INSERT INTO #T VALUES (1),(2),(3);
-        """)
+        try await client.run(
+            """
+                IF OBJECT_ID('tempdb..#T') IS NOT NULL DROP TABLE #T;
+                CREATE TABLE #T (id INT);
+                INSERT INTO #T VALUES (1),(2),(3);
+            """)
         let affected = try await client.run("UPDATE #T SET id = id + 10")
         XCTAssertEqual(affected, 3)
         try await client.run("DROP TABLE #T")
@@ -139,42 +141,48 @@ final class SQLClientSwiftTests: XCTestCase {
         do {
             _ = try await client.execute("SELECT ? AS A", parameters: [1, 2])
             XCTFail("Expected parameterCountMismatch")
-        } catch SQLClientError.parameterCountMismatch { }
+        } catch SQLClientError.parameterCountMismatch {}
     }
 
     func testDecodableStruct() async throws {
-        struct Point: Decodable { let x: Int; let y: Int }
+        struct Point: Decodable {
+            let x: Int
+            let y: Int
+        }
         let points: [Point] = try await client.query("SELECT 10 AS x, 20 AS y")
         XCTAssertEqual(points[0].x, 10)
         XCTAssertEqual(points[0].y, 20)
     }
 
     func testDecodableSnakeCase() async throws {
-        struct Item: Decodable { let itemId: Int; let itemName: String }
+        struct Item: Decodable {
+            let itemId: Int
+            let itemName: String
+        }
         let items: [Item] = try await client.query("SELECT 7 AS item_id, 'Widget' AS item_name")
-        XCTAssertEqual(items[0].itemId,   7)
+        XCTAssertEqual(items[0].itemId, 7)
         XCTAssertEqual(items[0].itemName, "Widget")
     }
 
     func testBadSQLThrows() async throws {
         do {
             _ = try await client.execute("THIS IS NOT VALID SQL")
             XCTFail("Expected executionFailed")
-        } catch SQLClientError.executionFailed { }
+        } catch SQLClientError.executionFailed {}
     }
 
     func testEmptySQLThrows() async throws {
         do {
             _ = try await client.execute("   ")
             XCTFail("Expected noCommandText")
-        } catch SQLClientError.noCommandText { }
+        } catch SQLClientError.noCommandText {}
     }
 
     func testQueryBeforeConnectThrows() async throws {
         let client = SQLClient()
         do {
             _ = try await client.query("SELECT 1")
             XCTFail("Expected notConnected")
-        } catch SQLClientError.notConnected { }
+        } catch SQLClientError.notConnected {}
     }
 }