add iOS

2025-01-28 12:28:03 +08:00
parent 738c373a77
commit ec96756800
2534 changed files with 486292 additions and 0 deletions
@@ -0,0 +1,243 @@
+import Foundation
+import XCTest
+@testable import GRDB
+
+// Support for Database.logError
+var lastResultCode: ResultCode? = nil
+var lastMessage: String? = nil
+let logErrorSetup: Void = {
+    let lock = NSLock()
+    Database.logError = { (resultCode, message) in
+        lock.lock()
+        defer { lock.unlock() }
+        lastResultCode = resultCode
+        lastMessage = message
+    }
+}()
+
+class GRDBTestCase: XCTestCase {
+    // The default configuration for tests
+    var dbConfiguration: Configuration!
+    
+    // Builds a database queue based on dbConfiguration
+    func makeDatabaseQueue(filename: String? = nil) throws -> DatabaseQueue {
+        try makeDatabaseQueue(filename: filename, configuration: dbConfiguration)
+    }
+    
+    // Builds a database queue
+    func makeDatabaseQueue(filename: String? = nil, configuration: Configuration) throws -> DatabaseQueue {
+        try FileManager.default.createDirectory(atPath: dbDirectoryPath, withIntermediateDirectories: true, attributes: nil)
+        let dbPath = (dbDirectoryPath as NSString).appendingPathComponent(filename ?? ProcessInfo.processInfo.globallyUniqueString)
+        let dbQueue = try DatabaseQueue(path: dbPath, configuration: configuration)
+        try setup(dbQueue)
+        return dbQueue
+    }
+    
+    // Builds a database pool based on dbConfiguration
+    func makeDatabasePool(filename: String? = nil) throws -> DatabasePool {
+        try makeDatabasePool(filename: filename, configuration: dbConfiguration)
+    }
+    
+    // Builds a database pool
+    func makeDatabasePool(filename: String? = nil, configuration: Configuration) throws -> DatabasePool {
+        try FileManager.default.createDirectory(atPath: dbDirectoryPath, withIntermediateDirectories: true, attributes: nil)
+        let dbPath = (dbDirectoryPath as NSString).appendingPathComponent(filename ?? ProcessInfo.processInfo.globallyUniqueString)
+        let dbPool = try DatabasePool(path: dbPath, configuration: configuration)
+        try setup(dbPool)
+        return dbPool
+    }
+    
+    // Subclasses can override
+    // Default implementation is empty.
+    func setup(_ dbWriter: some DatabaseWriter) throws {
+    }
+    
+    // The default path for database pool directory
+    private var dbDirectoryPath: String!
+    
+    // Populated by default configuration
+    @LockedBox var sqlQueries: [String] = []
+    
+    // Populated by default configuration
+    var lastSQLQuery: String? { sqlQueries.last }
+    
+    override func setUp() {
+        super.setUp()
+        
+        _ = logErrorSetup
+        
+        let dbPoolDirectoryName = "GRDBTestCase-\(ProcessInfo.processInfo.globallyUniqueString)"
+        dbDirectoryPath = (NSTemporaryDirectory() as NSString).appendingPathComponent(dbPoolDirectoryName)
+        do { try FileManager.default.removeItem(atPath: dbDirectoryPath) } catch { }
+        
+        dbConfiguration = Configuration()
+        
+        // Test that database are deallocated in a clean state
+        dbConfiguration.SQLiteConnectionWillClose = { sqliteConnection in
+            // https://www.sqlite.org/capi3ref.html#sqlite3_close:
+            // > If sqlite3_close_v2() is called on a database connection that still
+            // > has outstanding prepared statements, BLOB handles, and/or
+            // > sqlite3_backup objects then it returns SQLITE_OK and the
+            // > deallocation of resources is deferred until all prepared
+            // > statements, BLOB handles, and sqlite3_backup objects are also
+            // > destroyed.
+            //
+            // Let's assert that there is no longer any busy update statements.
+            //
+            // SQLite would allow that. But not GRDB, since all updates happen
+            // in closures that retain database connections, preventing
+            // Database.deinit to fire.
+            //
+            // What we gain from this test is a guarantee that database
+            // deallocation implies that there is no pending lock in the
+            // database.
+            //
+            // See:
+            // - sqlite3_next_stmt https://www.sqlite.org/capi3ref.html#sqlite3_next_stmt
+            // - sqlite3_stmt_busy https://www.sqlite.org/capi3ref.html#sqlite3_stmt_busy
+            // - sqlite3_stmt_readonly https://www.sqlite.org/capi3ref.html#sqlite3_stmt_readonly
+            var stmt: SQLiteStatement? = sqlite3_next_stmt(sqliteConnection, nil)
+            while stmt != nil {
+                XCTAssertTrue(sqlite3_stmt_readonly(stmt) != 0 || sqlite3_stmt_busy(stmt) == 0)
+                stmt = sqlite3_next_stmt(sqliteConnection, stmt)
+            }
+        }
+        
+        dbConfiguration.prepareDatabase { db in
+            db.trace { event in
+                self.sqlQueries.append(event.expandedDescription)
+            }
+            
+            #if GRDBCIPHER_USE_ENCRYPTION
+            try db.usePassphrase("secret")
+            #endif
+        }
+        
+        sqlQueries = []
+    }
+    
+    override func tearDown() {
+        super.tearDown()
+        do { try FileManager.default.removeItem(atPath: dbDirectoryPath) } catch { }
+    }
+    
+    func assertNoError(file: StaticString = #file, line: UInt = #line, _ test: () throws -> Void) {
+        do {
+            try test()
+        } catch {
+            XCTFail("unexpected error: \(error)", file: file, line: line)
+        }
+    }
+    
+    func assertDidExecute(sql: String, file: StaticString = #file, line: UInt = #line) {
+        XCTAssertTrue(sqlQueries.contains(sql), "Did not execute \(sql)", file: file, line: line)
+    }
+    
+    func assert(_ record: some EncodableRecord, isEncodedIn row: Row, file: StaticString = #file, line: UInt = #line) throws {
+        let recordDict = try record.databaseDictionary
+        let rowDict = Dictionary(row, uniquingKeysWith: { (left, _) in left })
+        XCTAssertEqual(recordDict, rowDict, file: file, line: line)
+    }
+    
+    // Compare SQL strings (ignoring leading and trailing white space and semicolons.
+    func assertEqualSQL(_ lhs: String, _ rhs: String, file: StaticString = #file, line: UInt = #line) {
+        // Trim white space and ";"
+        let cs = CharacterSet.whitespacesAndNewlines.union(CharacterSet(charactersIn: ";"))
+        XCTAssertEqual(lhs.trimmingCharacters(in: cs), rhs.trimmingCharacters(in: cs), file: file, line: line)
+    }
+    
+    // Compare SQL strings (ignoring leading and trailing white space and semicolons.
+    func assertEqualSQL(
+        _ db: Database,
+        _ request: some FetchRequest,
+        _ sql: String,
+        file: StaticString = #file,
+        line: UInt = #line)
+    throws
+    {
+        try request.makeStatement(db).makeCursor().next()
+        assertEqualSQL(lastSQLQuery!, sql, file: file, line: line)
+    }
+    
+    // Compare SQL strings.
+    func assertEqualSQL(
+        _ db: Database,
+        _ expression: some SQLExpressible,
+        _ sql: String,
+        file: StaticString = #file,
+        line: UInt = #line)
+    throws
+    {
+        let request: SQLRequest<Row> = "SELECT \(expression)"
+        try assertEqualSQL(db, request, "SELECT \(sql)", file: file, line: line)
+    }
+    
+    // Compare SQL strings (ignoring leading and trailing white space and semicolons.
+    func assertEqualSQL(
+        _ databaseReader: some DatabaseReader,
+        _ request: some FetchRequest,
+        _ sql: String,
+        file: StaticString = #file,
+        line: UInt = #line)
+    throws
+    {
+        try databaseReader.unsafeRead { db in
+            try assertEqualSQL(db, request, sql, file: file, line: line)
+        }
+    }
+
+    func sql(
+        _ databaseReader: some DatabaseReader,
+        _ request: some FetchRequest)
+    -> String
+    {
+        try! databaseReader.unsafeRead { db in
+            try request.makeStatement(db).makeCursor().next()
+            return lastSQLQuery!
+        }
+    }
+}
+
+#if SWIFT_PACKAGE
+let testBundle = Bundle.module
+#else
+let testBundle = Bundle(for: GRDBTestCase.self)
+#endif
+
+extension FetchRequest {
+    /// Turn request into a statement
+    func makeStatement(_ db: Database) throws -> Statement {
+        try makePreparedRequest(db, forSingleResult: false).statement
+    }
+    
+    /// Turn request into SQL and arguments
+    func build(_ db: Database) throws -> (sql: String, arguments: StatementArguments) {
+        let statement = try makePreparedRequest(db, forSingleResult: false).statement
+        return (sql: statement.sql, arguments: statement.arguments)
+    }
+}
+
+/// A type-erased ValueReducer.
+public struct AnyValueReducer<Fetched, Value>: ValueReducer {
+    private var __fetch: (Database) throws -> Fetched
+    private var __value: (Fetched) -> Value?
+    
+    public init(
+        fetch: @escaping (Database) throws -> Fetched,
+        value: @escaping (Fetched) -> Value?)
+    {
+        self.__fetch = fetch
+        self.__value = value
+    }
+    
+    public func _fetch(_ db: Database) throws -> Fetched {
+        try __fetch(db)
+    }
+    
+    public func _value(_ fetched: Fetched) -> Value? {
+        __value(fetched)
+    }
+}
+
+// Assume this is correct :-/
+extension XCTestExpectation: @unchecked Sendable { }