[Testing] Convert more tests to swift-testing (#93)

Author: joshuawright11

.github/workflows/test.yml

@@ -17,12 +17,12 @@ jobs:
             - name: Build
               run: swift build
             - name: Run tests
-              run: swift test
+              run: swift test --no-parallel
     test-linux:
         runs-on: ubuntu-22.04
         strategy:
             matrix:
-                swift: ["6.0"]
+                swift: ["6.1"]
         container: swift:${{ matrix.swift }}
         steps:
             - uses: actions/checkout@v3
@@ -31,4 +31,4 @@ jobs:
             - name: Build
               run: swift build
             - name: Run tests
-              run: swift test
+              run: swift test --no-parallel

Alchemy/Sources/Application/Application.swift

@@ -39,8 +39,7 @@ public protocol Application: Router {
 extension Application {
     /// @main support
     public static func main() async throws {
-        Main = Self()
-        try await Main.start()
+        try await Self().start()
     }
 
     /// Start the app. This boots the app, runs a command based on arguments,
@@ -73,6 +72,7 @@ extension Application {
 
     /// Sets up the app for running.
     public func willRun() async throws {
+        Main = self
         try await Life.boot()
     }
 

Alchemy/Sources/Application/Services+Application.swift

@@ -20,15 +20,26 @@ public var Thread: NIOThreadPool { Container.$threadPool }
 
 /// The current application.
 public internal(set) var Main: Application {
-    get { Container.$application }
-    set { Container.$application = newValue }
+    get { Container.main.application }
+    set { Container.main.application = newValue }
 }
 
 // MARK: Services
 
 extension Container {
-    @Singleton public var application: Application { fatalError("Default application hasn't been set!") }
-    @Singleton public var lifecycle = Lifecycle(app: $application)
+    var application: Application {
+        get {
+            guard let $_application else {
+                preconditionFailure("The main application hasn't been registered. Has `app.willRun` been called?")
+            }
+
+            return $_application
+        }
+        set { $_application = newValue }
+    }
+
+    @Singleton var _application: Application? = nil
+    @Singleton public var lifecycle = Lifecycle(app: application)
     @Singleton public var env: Environment = .createDefault()
     @Singleton public var threadPool: NIOThreadPool = .singleton
     @Singleton public var eventLoopGroup: EventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: isTest ? 1 : System.coreCount)

Alchemy/Sources/Auth/BasicAuthable.swift

@@ -77,8 +77,8 @@ extension BasicAuthable {
     ///
     /// - Returns: A `BasicAuthMiddleware<Self>` for authenticating
     ///   requests.
-    public static func basicAuthMiddleware() -> BasicAuthMiddleware<Self> {
-        BasicAuthMiddleware()
+    public static func basicAuthMiddleware(db: Database = DB) -> BasicAuthMiddleware<Self> {
+        BasicAuthMiddleware(db: db)
     }
 
     /// Authenticates this model with a username and password.
@@ -91,8 +91,13 @@ extension BasicAuthable {
     /// - Returns: A the authenticated `BasicAuthable`, if there was
     ///   one. Throws `error` if the model is not found, or the
     ///   password doesn't match.
-    public static func authenticate(username: String, password: String, else error: Error = HTTPError(.unauthorized)) async throws -> Self {
-        let rows = try await DB
+    public static func authenticate(
+        db: Database = DB,
+        username: String,
+        password: String,
+        else error: Error = HTTPError(.unauthorized)
+    ) async throws -> Self {
+        let rows = try await db
             .table(Self.table)
             .where(usernameKeyString == username)
             .select("\(table).*", passwordKeyString)
@@ -122,12 +127,18 @@ extension BasicAuthable {
 /// basic auth values don't match a row in the database, an
 /// `HTTPError(.unauthorized)` will be thrown.
 public struct BasicAuthMiddleware<B: BasicAuthable>: Middleware {
+    private let db: Database
+
+    public init(db: Database = DB) {
+        self.db = db
+    }
+
     public func handle(_ request: Request, next: Next) async throws -> Response {
         guard let basicAuth = request.basicAuth() else {
             throw HTTPError(.unauthorized)
         }
 
-        let model = try await B.authenticate(username: basicAuth.username, password: basicAuth.password)
+        let model = try await B.authenticate(db: db, username: basicAuth.username, password: basicAuth.password)
         return try await next(request.set(model))
     }
 }

Alchemy/Sources/Auth/TokenAuthable.swift

@@ -39,7 +39,7 @@ public protocol TokenAuthable: Model {
     /// associated with the request.
     associatedtype Authorizes: Model
 
-    /// The user in question.
+    /// The user this token authorizes.
     var user: Authorizes { get async throws }
 
     /// The name of the row that stores the token's value. Defaults to "value"`.
@@ -55,8 +55,8 @@ extension TokenAuthable {
     ///
     /// - Returns: A `TokenAuthMiddleware<Self>` for authenticating
     ///   requests.
-    public static func tokenAuthMiddleware() -> TokenAuthMiddleware<Self> {
-        TokenAuthMiddleware()
+    public static func tokenAuthMiddleware(db: Database = DB) -> TokenAuthMiddleware<Self> {
+        TokenAuthMiddleware(db: db)
     }
 }
 
@@ -68,12 +68,19 @@ extension TokenAuthable {
 /// header, or the token value isn't valid, an
 /// `HTTPError(.unauthorized)` will be thrown.
 public struct TokenAuthMiddleware<T: TokenAuthable>: Middleware {
+    private let db: Database
+
+    init(db: Database = DB) {
+        self.db = db
+    }
+
     public func handle(_ request: Request, next: Next) async throws -> Response {
         guard let bearerAuth = request.bearerAuth() else {
             throw HTTPError(.unauthorized)
         }
 
         guard let model = try await T
+            .query(on: db)
             .where(T.valueKeyString == bearerAuth.token)
             .first()
         else {

Alchemy/Sources/Database/Database.swift

@@ -33,9 +33,15 @@ public final class Database {
         self.provider = provider
         self.grammar = grammar
         self.logging = logging
-        self.migrations = Main.migrations
-        self.seeders = Main.seeders
-        Life.onShutdown { try await provider.shutdown() }
+
+        if let app = Container.$_application {
+            self.migrations = app.migrations
+            self.seeders = app.seeders
+            Life.onShutdown { try await provider.shutdown() }
+        } else {
+            self.migrations = []
+            self.seeders = []
+        }
     }
 
     /// Log all executed queries to the `debug` level.

Alchemy/Sources/Database/Migrations/Database+Migration.swift

@@ -37,31 +37,13 @@ extension Database {
         let runAt: Date?
     }
 
-    /// Applies all outstanding migrations to the database in a single
-    /// batch. Migrations are read from `database.migrations`.
-    public func migrate() async throws {
-        let applied = try await getAppliedMigrations().map(\.name)
-        let toApply = migrations.filter { !applied.contains($0.name) }
-        try await migrate(toApply)
-    }
-
-    /// Rolls back all migrations from all batches.
-    public func reset() async throws {
-        try await rollback(getAppliedMigrations().reversed())
-    }
-
-    /// Rolls back the latest migration batch.
-    public func rollback() async throws {
-        let lastBatch = try await getLastBatch()
-        let migrations = try await getAppliedMigrations(batch: lastBatch, enforceRegistration: true)
-        try await rollback(migrations.reversed())
-    }
+    /// Applies the provided migrations or all outstanding migrations to the
+    /// database in a single batch. Migrations are read from
+    /// `database.migrations`.
+    public func migrate(_ migrations: [Migration]? = nil) async throws {
+        let appliedMigrations = try await getAppliedMigrations().map(\.name)
+        let migrations = (migrations ?? self.migrations).filter { !appliedMigrations.contains($0.name) }
 
-    /// Run the `.up` functions of an array of migrations in order.
-    ///
-    /// - Parameters:
-    ///   - migrations: The migrations to apply to this database.
-    public func migrate(_ migrations: [Migration]) async throws {
         guard !migrations.isEmpty else {
             Log.info("Nothing to migrate.".green)
             return
@@ -77,6 +59,18 @@ extension Database {
         }
     }
 
+    /// Rolls back all migrations from all batches.
+    public func reset() async throws {
+        try await rollback(getAppliedMigrations().reversed())
+    }
+
+    /// Rolls back the latest migration batch.
+    public func rollback() async throws {
+        let lastBatch = try await getLastBatch()
+        let migrations = try await getAppliedMigrations(batch: lastBatch, enforceRegistration: true)
+        try await rollback(migrations.reversed())
+    }
+
     /// Run the `.down` functions of an array of migrations, in order.
     ///
     /// - Parameter migrations: The migrations to rollback on this

Alchemy/Sources/Database/Query/Query+Where.swift

@@ -56,7 +56,7 @@ public struct SQLWhere: Hashable, SQLConvertible {
                 } else if op == .equals {
                     return SQL("\(boolean) \(key) IS NULL")
                 } else {
-                    fatalError("Can't use any where operators other than .notEqualTo or .equals if the value is NULL.")
+                    preconditionFailure("Can't use any where operators other than .notEqualTo or .equals if the value is NULL.")
                 }
             } else {
                 return SQL("\(boolean) \(key) \(op) ?", input: [sql])

Alchemy/Sources/Database/Rune/Model/Coding/SQLRowEncoder.swift

@@ -21,19 +21,19 @@ final class SQLRowEncoder: Encoder {
         }
 
         mutating func nestedContainer<NestedKey: CodingKey>(keyedBy keyType: NestedKey.Type, forKey key: Key) -> KeyedEncodingContainer<NestedKey> {
-            fatalError("Nested coding of `Model` not supported.")
+            preconditionFailure("Nested coding of `Model` not supported.")
         }
 
         mutating func nestedUnkeyedContainer(forKey key: Key) -> UnkeyedEncodingContainer {
-            fatalError("Nested coding of `Model` not supported.")
+            preconditionFailure("Nested coding of `Model` not supported.")
         }
 
         mutating func superEncoder() -> Encoder {
-            fatalError("Superclass encoding of `Model` not supported.")
+            preconditionFailure("Superclass encoding of `Model` not supported.")
         }
 
         mutating func superEncoder(forKey key: Key) -> Encoder {
-            fatalError("Superclass encoding of `Model` not supported.")
+            preconditionFailure("Superclass encoding of `Model` not supported.")
         }
     }
 
@@ -73,10 +73,10 @@ final class SQLRowEncoder: Encoder {
     }
 
     func unkeyedContainer() -> UnkeyedEncodingContainer {
-        fatalError("`Model`s should never encode to an unkeyed container.")
+        preconditionFailure("`Model`s should never encode to an unkeyed container.")
     }
 
     func singleValueContainer() -> SingleValueEncodingContainer {
-        fatalError("`Model`s should never encode to a single value container.")
+        preconditionFailure("`Model`s should never encode to a single value container.")
     }
 }

Alchemy/Sources/Database/Rune/Model/Model+CRUD.swift

@@ -126,10 +126,10 @@ extension Model {
     }
 
     @discardableResult
-    public func update<E: Encodable>(on db: Database = database, _ encodable: E, keyMapping: KeyMapping = .snakeCase, jsonEncoder: JSONEncoder = JSONEncoder()) async throws -> Self {
-        let fields = try encodable.sqlFields(keyMapping: keyMapping, jsonEncoder: jsonEncoder)
-        print("fields \(fields)")
-        return try await update(encodable.sqlFields(keyMapping: keyMapping, jsonEncoder: jsonEncoder))
+    public func update<E: Encodable>(on db: Database = database,
+                                     _ encodable: E, keyMapping: KeyMapping = .snakeCase,
+                                     jsonEncoder: JSONEncoder = JSONEncoder()) async throws -> Self {
+        try await update(on: db, encodable.sqlFields(keyMapping: keyMapping, jsonEncoder: jsonEncoder))
     }
 
     // MARK: UPSERT