Update AppTestCase

Author: finestructure

Tests/AppTests/AppTestCase.swift

@@ -19,46 +19,16 @@ import Fluent
 import NIOConcurrencyHelpers
 import PostgresNIO
 import SQLKit
+#warning("drop all instances of import XCTVapor")
 import XCTVapor
 
 
-class AppTestCase: XCTestCase {
-    var app: Application!
-    let logger = CapturingLogger()
+#warning("move/rename")
+enum AppTestCase {
 
-    override func setUp() async throws {
-        try await super.setUp()
-        app = try await setup(.testing)
-
-        @Dependency(\.logger) var logger
-        logger.set(to: self.logger)
-    }
-
-    func setup(_ environment: Environment) async throws -> Application {
-        try await withDependencies {
-            // Setting builderToken here when it's also set in all tests may seem redundant but it's
-            // what allows test_post_buildReport_large to work.
-            // See https://github.com/pointfreeco/swift-dependencies/discussions/300#discussioncomment-11252906
-            // for details.
-            $0.environment.builderToken = { "secr3t" }
-        } operation: {
-            try await Self.setupDb(environment)
-            return try await Self.setupApp(environment)
-        }
-    }
-
-    override func tearDown() async throws {
-        try await app.asyncShutdown()
-        try await super.tearDown()
-    }
-}
-
-
-extension AppTestCase {
-
-    static func setupApp(_ environment: Environment) async throws -> Application {
+    static func setupApp(_ environment: Environment, databasePort: Int) async throws -> Application {
         let app = try await Application.make(environment)
-        try await configure(app)
+        try await configure(app, databasePort: databasePort)
 
         // Silence app logging
         app.logger = .init(label: "noop") { _ in SwiftLogNoOpLogHandler() }
@@ -67,7 +37,7 @@ extension AppTestCase {
     }
 
 
-    static func setupDb(_ environment: Environment) async throws {
+    static func setupDb(_ environment: Environment, databasePort: Int) async throws {
         await DotEnvFile.load(for: environment, fileio: .init(threadPool: .singleton))
 
         // Ensure DATABASE_HOST is from a restricted set db hostnames and nothing else.
@@ -83,27 +53,29 @@ extension AppTestCase {
         // Create initial db snapshot on first run
         try await snapshotCreated.withValue { snapshotCreated in
             if !snapshotCreated {
-                try await createSchema(environment, databaseName: testDbName)
-                try await createSnapshot(original: testDbName, snapshot: snapshotName, environment: environment)
+                try await createSchema(environment, databaseName: testDbName, databasePort: databasePort)
+                try await createSnapshot(original: testDbName, snapshot: snapshotName, databasePort: databasePort, environment: environment)
                 snapshotCreated = true
             }
         }
 
-        try await restoreSnapshot(original: testDbName, snapshot: snapshotName, environment: environment)
+        try await restoreSnapshot(original: testDbName, snapshot: snapshotName, databasePort: databasePort, environment: environment)
     }
 
 
-    static func createSchema(_ environment: Environment, databaseName: String) async throws {
+    static func createSchema(_ environment: Environment,
+                             databaseName: String,
+                             databasePort: Int) async throws {
         do {
-            try await withDatabase("postgres", environment) {  // Connect to `postgres` db in order to reset the test db
+            try await withDatabase("postgres", port: databasePort, environment) {  // Connect to `postgres` db in order to reset the test db
                 try await $0.query(PostgresQuery(unsafeSQL: "DROP DATABASE IF EXISTS \(databaseName) WITH (FORCE)"))
                 try await $0.query(PostgresQuery(unsafeSQL: "CREATE DATABASE \(databaseName)"))
             }
 
             do {  // Use autoMigrate to spin up the schema
                 let app = try await Application.make(environment)
                 app.logger = .init(label: "noop") { _ in SwiftLogNoOpLogHandler() }
-                try await configure(app)
+                try await configure(app, databasePort: databasePort)
                 try await app.autoMigrate()
                 try await app.asyncShutdown()
             }
@@ -114,9 +86,12 @@ extension AppTestCase {
     }
 
 
-    static func createSnapshot(original: String, snapshot: String, environment: Environment) async throws {
+    static func createSnapshot(original: String,
+                               snapshot: String,
+                               databasePort: Int,
+                               environment: Environment) async throws {
         do {
-            try await withDatabase("postgres", environment) { client in
+            try await withDatabase("postgres", port: databasePort, environment) { client in
                 try await client.query(PostgresQuery(unsafeSQL: "DROP DATABASE IF EXISTS \(snapshot) WITH (FORCE)"))
                 try await client.query(PostgresQuery(unsafeSQL: "CREATE DATABASE \(snapshot) TEMPLATE \(original)"))
             }
@@ -127,10 +102,13 @@ extension AppTestCase {
     }
 
 
-    static func restoreSnapshot(original: String, snapshot: String, environment: Environment) async throws {
+    static func restoreSnapshot(original: String,
+                                snapshot: String,
+                                databasePort: Int,
+                                environment: Environment) async throws {
         // delete db and re-create from snapshot
         do {
-            try await withDatabase("postgres", environment) { client in
+            try await withDatabase("postgres", port: databasePort, environment) { client in
                 try await client.query(PostgresQuery(unsafeSQL: "DROP DATABASE IF EXISTS \(original) WITH (FORCE)"))
                 try await client.query(PostgresQuery(unsafeSQL: "CREATE DATABASE \(original) TEMPLATE \(snapshot)"))
             }
@@ -146,42 +124,6 @@ extension AppTestCase {
 }
 
 
-extension AppTestCase {
-    func renderSQL(_ builder: SQLSelectBuilder) -> String {
-        renderSQL(builder.query)
-    }
-
-    func renderSQL(_ query: SQLExpression) -> String {
-        var serializer = SQLSerializer(database: app.db as! SQLDatabase)
-        query.serialize(to: &serializer)
-        return serializer.sql
-    }
-
-    func binds(_ builder: SQLSelectBuilder?) -> [String] {
-        binds(builder?.query)
-    }
-
-    func binds(_ query: SQLExpression?) -> [String] {
-        var serializer = SQLSerializer(database: app.db as! SQLDatabase)
-        query?.serialize(to: &serializer)
-        return serializer.binds.reduce(into: []) { result, bind in
-            switch bind {
-                case let bind as Date:
-                    result.append(DateFormatter.filterParseFormatter.string(from: bind))
-                case let bind as Set<Package.PlatformCompatibility>:
-                    let s = bind.map(\.rawValue).sorted().joined(separator: ",")
-                    result.append("{\(s)}")
-                case let bind as Set<ProductTypeSearchFilter.ProductType>:
-                    let s = bind.map(\.rawValue).sorted().joined(separator: ",")
-                    result.append("{\(s)}")
-                default:
-                    result.append("\(bind)")
-            }
-        }
-    }
-}
-
-
 // FIXME: Move this once AppTestCase can be removed. These are helpers created during the transition to Swift Testing. Also check if we can just create a PostgresDB object from scratch rather than using withApp and app.db for this at the call site. That does a whole migration + reset just to render the SQL needlessly.
 extension Database {
     func renderSQL(_ builder: SQLSelectBuilder) -> String {
@@ -219,10 +161,12 @@ extension Database {
 }
 
 
-private func connect(to databaseName: String, _ environment: Environment) async throws -> PostgresClient {
+private func connect(to databaseName: String,
+                     port: Int,
+                     _ environment: Environment) async throws -> PostgresClient {
     await DotEnvFile.load(for: environment, fileio: .init(threadPool: .singleton))
     let host = Environment.get("DATABASE_HOST")!
-    let port = Environment.get("DATABASE_PORT").flatMap(Int.init)!
+//    let port = Environment.get("DATABASE_PORT").flatMap(Int.init)!
     let username = Environment.get("DATABASE_USERNAME")!
     let password = Environment.get("DATABASE_PASSWORD")!
 
@@ -232,8 +176,11 @@ private func connect(to databaseName: String, _ environment: Environment) async
 }
 
 
-private func withDatabase(_ databaseName: String, _ environment: Environment, _ query: @escaping (PostgresClient) async throws -> Void) async throws {
-    let client = try await connect(to: databaseName, environment)
+private func withDatabase(_ databaseName: String,
+                          port: Int,
+                          _ environment: Environment,
+                          _ query: @escaping (PostgresClient) async throws -> Void) async throws {
+    let client = try await connect(to: databaseName, port: port, environment)
     try await withThrowingTaskGroup(of: Void.self) { taskGroup in
         taskGroup.addTask { await client.run() }