Some tests

Author: wickwirew

Sources/Feather/ConnectionPool.swift

@@ -59,7 +59,7 @@ public actor ConnectionPool: Sendable {
     }
 
     /// Whether or not we have created all the connections we are allowed too
-    private var isAtConnectionLimit: Bool {
+    var isAtConnectionLimit: Bool {
         return count >= limit
     }
 
@@ -89,7 +89,7 @@ public actor ConnectionPool: Sendable {
     private func getConnection() async throws(FeatherError) -> SQLiteConnection {
         guard availableConnections.isEmpty else {
             // Have an available connection, just use it
-            return availableConnections.removeFirst()
+            return availableConnections.removeLast()
         }
 
         guard !isAtConnectionLimit else {

Sources/Feather/Cursor.swift

@@ -9,7 +9,6 @@ import SQLite3
 
 public struct Cursor<Element: RowDecodable>: ~Copyable {
     private let statement: Statement
-    private var column: Int32 = 0
 
     public init(of statement: consuming Statement) {
         self.statement = statement

Sources/Feather/Database.swift

@@ -5,12 +5,35 @@
 //  Created by Wes Wickwire on 5/4/25.
 //
 
+import Foundation
+
+/// The base protocol every generated database conforms too.
 public protocol Database {
+    /// The connection to use
     init(connection: any Connection)
+    /// An ordered list of migrations to be run.
     static var migrations: [String] { get }
 }
 
 public extension Database {
+    /// Opens a connection pool to the database at the given URL.
+    ///
+    /// - Parameter url: The url of the database file
+    init(url: URL) throws {
+        self = try Self(path: url.path)
+    }
+    
+    /// Opens a connection pool to the database at the given path.
+    ///
+    /// - Parameter path: The path of the database file
+    init(path: String) throws {
+        self = try Self(config: DatabaseConfig(path: path))
+    }
+    
+    /// Opens a connection pool to the database
+    ///
+    /// - Parameter config: The configuration specifying any info
+    /// needed to open the database.
     init(config: DatabaseConfig) throws {
         let connection: any Connection = if let path = config.path {
             try ConnectionPool(
@@ -29,6 +52,8 @@ public extension Database {
         self = Self(connection: connection)
     }
 
+    
+    /// Creates an in memory database.
     static func inMemory() throws -> Self {
         return try Self(config: DatabaseConfig(path: nil))
     }

Sources/Feather/DatabasePrimitive.swift

@@ -10,6 +10,10 @@ import Foundation
 
 @usableFromInline let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
 
+/// A type that is mapped directly to a SQLite type.
+///
+/// You **should not** be conforming any of your types to this directly.
+/// It will have no effect. For custom type conversion see `DatabasePrimitiveConvertible`
 public protocol DatabasePrimitive: RowDecodable {
     init(from cursor: OpaquePointer, at index: Int32) throws(FeatherError)
     func bind(to statement: OpaquePointer, at index: Int32) throws(FeatherError)

Sources/Feather/DatabaseQuery.swift

@@ -5,6 +5,7 @@
 //  Created by Wes Wickwire on 11/9/24.
 //
 
+/// A query which reads or writes to a database.
 public protocol DatabaseQuery<Input, Output>: Query {
     /// Whether the query requires a read or write transaction.
     var transactionKind: Transaction.Kind { get }

Sources/Feather/FeatherError.swift

@@ -5,7 +5,7 @@
 //  Created by Wes Wickwire on 2/16/25.
 //
 
-public enum FeatherError: Error {
+public enum FeatherError: Error, Equatable {
     case failedToOpenConnection(path: String)
     case failedToInitializeStatement
     case columnIsNil(Int32)
@@ -21,10 +21,19 @@ public enum FeatherError: Error {
     /// to be started twice.
     case subscriptionAlreadyStarted
     case invalidUuidString
-    case cannotDecode(Any.Type, from: Any.Type)
-    case cannotEncode(Any.Type, to: Any.Type)
+    case cannotDecode(String, from: String)
+    case cannotEncode(String, to: String)
     case decodingError(String)
     case encodingError(String)
     case requiredAssociationFailed(parent: String, childKey: String)
     case cannotObserveWriteQuery
+    case cannotWriteInAReadTransaction
+    
+    public static func cannotDecode(_ type: Any.Type, from otherType: Any.Type) -> FeatherError {
+        return .cannotDecode("\(type)", from: "\(otherType)")
+    }
+    
+    public static func cannotEncode(_ type: Any.Type, to otherType: Any.Type) -> FeatherError {
+        return .cannotEncode("\(type)", to: "\(otherType)")
+    }
 }

Sources/Feather/Queries/AnyDatabaseQuery.swift

@@ -44,7 +44,11 @@ public struct AnyDatabaseQuery<Input, Output>: DatabaseQuery
         with input: Input,
         tx: borrowing Transaction
     ) throws -> Output {
-        try execute(input, tx)
+        guard tx.kind >= transactionKind else {
+            throw FeatherError.cannotWriteInAReadTransaction
+        }
+        
+        return try execute(input, tx)
     }
 }
 

Tests/FeatherTests/ConnectionPoolTests.swift

@@ -5,6 +5,7 @@
 //  Created by Wes Wickwire on 11/9/24.
 //
 
+import Foundation
 import Testing
 @testable import Feather
 
@@ -18,26 +19,23 @@ struct ConnectionPoolTests {
         let pool = try ConnectionPool(
             path: ":memory:",
             limit: 1,
-            migrations: [
-                "CREATE TABLE foo (bar INTEGER)"
-            ]
+            migrations: ["CREATE TABLE foo (bar INTEGER)"]
         )
 
         try await pool.begin(.read) { tx in
             _ = try Statement("SELECT * FROM foo", transaction: tx)
         }
     }
 
-    @Test func poolReusesConnections() async throws {
+    @Test func poolReclaimsConnectionWhenFinished() async throws {
         let pool = try ConnectionPool(
             path: ":memory:",
             limit: 1,
-            migrations: [
-                "CREATE TABLE foo (bar INTEGER)"
-            ]
+            migrations: ["CREATE TABLE foo (bar INTEGER)"]
         )
 
         // Will hang indefinitely if a connection isnt recycled
+        // since its a single connection
         for _ in 0..<10 {
             try await pool.begin(.read) { tx in
                 _ = try Statement("SELECT * FROM foo", transaction: tx)

Tests/FeatherTests/QueryTests.swift

@@ -11,99 +11,44 @@ import Testing
 
 @Suite
 struct QueryTests {
-    @Test func testQuery() async throws {
-        let pool = try createDatabase()
-        let insert = insertQuery(database: pool)
+    @Test func testInsertAndGetQuery() async throws {
+        let db = try TestDB.inTempDir()
+        try await db.insertFoo.execute(with: 1)
 
-        let foo1 = Foo(bar: 1, baz: "bar1")
-        let foo2 = Foo(bar: 2, baz: "bar2")
-        let foo3 = Foo(bar: 3, baz: "bar3")
+        let foos = try await db.selectFoos.execute()
+        #expect(foos == [TestDB.Foo(bar: 1)])
 
-        try await insert.execute(with: foo1)
-        try await insert.execute(with: foo2)
-        try await insert.execute(with: foo3)
-        
-        let foos = try await selectAllFooQuery(database: pool).execute()
-        
-        #expect(foos.count == 3)
+        let foo = try await db.selectFoo.execute(with: 1)
+        #expect(foo == TestDB.Foo(bar: 1))
     }
 
-//    @Test func testMacroQuery() async throws {
-//        let pool = try ConnectionPool(path: ":memory:", limit: 1, migrations: TestDB.migrations)
-//        
-//        try await TestDB.insertFoo.execute(with: .init(bar: 1, baz: "one"), in: pool)
-//        try await TestDB.insertFoo.execute(with: .init(bar: 2, baz: "two"), in: pool)
-//        
-//        let foos = try await TestDB.fetchFoos.execute(in: pool)
-//        #expect(foos.count == 2)
-//    }
+    @Test func selectManyWithEmptyDbReturnsEmpty() async throws {
+        let db = try TestDB.inTempDir()
+        let foos = try await db.selectFoos.execute()
+        #expect(foos == [])
+    }
 
-    struct Foo: RowDecodable {
-        let bar: Int
-        let baz: String?
-        
-        init(bar: Int, baz: String?) {
-            self.bar = bar
-            self.baz = baz
-        }
-        
-        init(row: borrowing Row, startingAt start: Int32) throws(FeatherError) {
-            self.bar = try row.value(at: 0)
-            self.baz = try row.value(at: 1)
-        }
+    @Test func selectManyCanReturnManyItems() async throws {
+        let db = try TestDB.inTempDir()
+        try await db.insertFoo.execute(with: 1)
+        try await db.insertFoo.execute(with: 2)
+        let foos = try await db.selectFoos.execute()
+        #expect(foos == [TestDB.Foo(bar: 1), TestDB.Foo(bar: 2)])
     }
 
-    private func selectAllFooQuery(database: any Connection) -> any DatabaseQuery<(), [Foo]> {
-        return AnyDatabaseQuery<(), [Foo]>(.read, in: database, watchingTables: []) { input, transaction in
-            let statement = try Statement(in: transaction) {
-                "SELECT * FROM foo;"
-            }
-            
-            return try statement.fetchAll(of: Foo.self)
-        }
+    @Test func selectSingleWithEmptyDbReturnsNil() async throws {
+        let db = try TestDB.inTempDir()
+        let foo = try await db.selectFoo.execute(with: 1)
+        #expect(foo == nil)
     }
 
-    private func insertQuery(database: any Connection) -> any DatabaseQuery<Foo, ()> {
-        return AnyDatabaseQuery<Foo, ()>(.write, in: database, watchingTables: []) { input, transaction in
-            let statement = try Statement(in: transaction) {
-                "INSERT INTO foo (bar, baz) VALUES (?, ?)"
-            } bind: { statement in
-                try statement.bind(value: input.bar, to: 1)
-                try statement.bind(value: input.baz, to: 2)
+    @Test func errorIsThrownWhenAttemptingToWriteToReadTx() async throws {
+        let db = try TestDB.inTempDir()
+        
+        await #expect(throws: FeatherError.cannotWriteInAReadTransaction) {
+            _ = try await db.connection.begin(.read) { tx in
+                try db.insertFoo.execute(with: 1, tx: tx)
             }
-            
-            _ = try statement.step()
         }
     }
-    
-    private func createDatabase() throws -> ConnectionPool {
-        return try ConnectionPool(
-            path: ":memory:",
-            limit: 1,
-            migrations: [
-                "CREATE TABLE foo (bar INTEGER PRIMARY KEY, baz TEXT)"
-            ]
-        )
-    }
-//    
-//    @Database
-//    struct TestDB: Database {
-//        static var migrations: [String] {
-//            return [
-//                "CREATE TABLE foo (bar INTEGER PRIMARY KEY, baz TEXT)"
-//            ]
-//        }
-//        
-//        static var queries: [String] {
-//            return [
-//                """
-//                DEFINE QUERY fetchFoos AS
-//                SELECT * FROM foo;
-//                
-//                DEFINE QUERY insertFoo AS
-//                INSERT INTO foo (bar, baz) VALUES (?, ?);
-//                """,
-//            ]
-//        }
-//    }
 }

Tests/FeatherTests/TestDatabase.swift

@@ -0,0 +1,47 @@
+//
+//  TestDatabase.swift
+//  Feather
+//
+//  Created by Wes Wickwire on 6/14/25.
+//
+
+import Feather
+import Foundation
+
+/// A database to use for unit tests
+@Database
+struct TestDB {
+    @Query("SELECT * FROM foo")
+    var selectFoos: SelectFoosDatabaseQuery
+    
+    @Query("SELECT * FROM foo WHERE bar = ?")
+    var selectFoo: SelectFooDatabaseQuery
+
+    @Query("INSERT INTO foo (bar) VALUES (?)")
+    var insertFoo: InsertFooDatabaseQuery
+    
+    static var migrations: [String] {
+        return [
+            "CREATE TABLE foo (bar INTEGER);"
+        ]
+    }
+}
+
+extension TestDB {
+    /// Creates a database on disk in the temp directory.
+    /// Will delete the DB if it already exists
+    static func inTempDir(
+        name: StaticString = #function,
+        maxConnectionCount: Int = 5
+    ) throws -> TestDB {
+        let temp = FileManager.default.temporaryDirectory
+            .appending(component: "\(name).db")
+        
+        if FileManager.default.fileExists(atPath: temp.path) {
+            try FileManager.default.removeItem(atPath: temp.path)
+        }
+        
+        let config = DatabaseConfig(path: temp.path, maxConnectionCount: maxConnectionCount)
+        return try TestDB(config: config)
+    }
+}