zeus
422 lines
17 KiB
Swift
422 lines
17 KiB
Swift
import XCTest
|
|
import GRDB
|
|
|
|
class DatabaseWriterTests : GRDBTestCase {
|
|
|
|
func testDatabaseQueueUnsafeReentrantWrite() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.unsafeReentrantWrite { db1 in
|
|
try db1.create(table: "table1") { t in
|
|
t.primaryKey("id", .integer)
|
|
}
|
|
try dbQueue.unsafeReentrantWrite { db2 in
|
|
try db2.execute(sql: "INSERT INTO table1 (id) VALUES (NULL)")
|
|
|
|
try dbQueue.unsafeReentrantWrite { db3 in
|
|
try XCTAssertEqual(Int.fetchOne(db3, sql: "SELECT * FROM table1"), 1)
|
|
XCTAssertTrue(db1 === db2)
|
|
XCTAssertTrue(db2 === db3)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func testDatabasePoolUnsafeReentrantWrite() throws {
|
|
let dbPool = try makeDatabasePool()
|
|
try dbPool.unsafeReentrantWrite { db1 in
|
|
try db1.create(table: "table1") { t in
|
|
t.primaryKey("id", .integer)
|
|
}
|
|
try dbPool.unsafeReentrantWrite { db2 in
|
|
try db2.execute(sql: "INSERT INTO table1 (id) VALUES (NULL)")
|
|
|
|
try dbPool.unsafeReentrantWrite { db3 in
|
|
try XCTAssertEqual(Int.fetchOne(db3, sql: "SELECT * FROM table1"), 1)
|
|
XCTAssertTrue(db1 === db2)
|
|
XCTAssertTrue(db2 === db3)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func testAsyncWriteWithoutTransactionSuccess() throws {
|
|
func test(_ dbWriter: some DatabaseWriter) throws {
|
|
let expectation = self.expectation(description: "updates")
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
dbWriter.asyncWriteWithoutTransaction { db in
|
|
// Make sure this block executes asynchronously
|
|
semaphore.wait()
|
|
do {
|
|
try db.execute(sql: "CREATE TABLE testAsyncWriteWithoutTransaction (a)")
|
|
} catch {
|
|
XCTFail("Unexpected error: \(error)")
|
|
}
|
|
expectation.fulfill()
|
|
}
|
|
semaphore.signal()
|
|
|
|
waitForExpectations(timeout: 2, handler: nil)
|
|
let tableExists = try dbWriter.read { try $0.tableExists("testAsyncWriteWithoutTransaction") }
|
|
XCTAssertTrue(tableExists)
|
|
}
|
|
|
|
try test(makeDatabaseQueue())
|
|
try test(makeDatabasePool())
|
|
}
|
|
|
|
func testAsyncWriteWithoutTransactionError() throws {
|
|
func test(_ dbWriter: some DatabaseWriter) throws {
|
|
let expectation = self.expectation(description: "updates")
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
dbWriter.asyncWriteWithoutTransaction { db in
|
|
// Make sure this block executes asynchronously
|
|
semaphore.wait()
|
|
do {
|
|
try db.execute(sql: "This is not SQL")
|
|
XCTFail("Expected error")
|
|
} catch let error as DatabaseError {
|
|
XCTAssertEqual(error.sql, "This is not SQL")
|
|
} catch {
|
|
XCTFail("Unexpected error: \(error)")
|
|
}
|
|
expectation.fulfill()
|
|
}
|
|
semaphore.signal()
|
|
waitForExpectations(timeout: 2, handler: nil)
|
|
}
|
|
|
|
try test(makeDatabaseQueue())
|
|
try test(makeDatabasePool())
|
|
}
|
|
|
|
func testAsyncWriteSuccess() throws {
|
|
func test(_ dbWriter: some DatabaseWriter) throws {
|
|
let expectation = self.expectation(description: "updates")
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
dbWriter.asyncWrite({ db in
|
|
// Make sure this block executes asynchronously
|
|
semaphore.wait()
|
|
try db.execute(sql: "CREATE TABLE testAsyncWrite (a)")
|
|
}, completion: { db, result in
|
|
XCTAssertFalse(db.isInsideTransaction)
|
|
switch result {
|
|
case .success:
|
|
break
|
|
case let .failure(error):
|
|
XCTFail("Unexpected error: \(error)")
|
|
}
|
|
expectation.fulfill()
|
|
})
|
|
semaphore.signal()
|
|
|
|
waitForExpectations(timeout: 2, handler: nil)
|
|
let tableExists = try dbWriter.read { try $0.tableExists("testAsyncWrite") }
|
|
XCTAssertTrue(tableExists)
|
|
}
|
|
|
|
try test(makeDatabaseQueue())
|
|
try test(makeDatabasePool())
|
|
}
|
|
|
|
func testAsyncWriteError() throws {
|
|
func test(_ dbWriter: some DatabaseWriter) throws {
|
|
let expectation = self.expectation(description: "updates")
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
dbWriter.asyncWrite({ db in
|
|
// Make sure this block executes asynchronously
|
|
semaphore.wait()
|
|
try db.execute(sql: "This is not SQL")
|
|
}, completion: { db, result in
|
|
XCTAssertFalse(db.isInsideTransaction)
|
|
switch result {
|
|
case .success:
|
|
XCTFail("Expected error")
|
|
case let .failure(error):
|
|
if let error = error as? DatabaseError {
|
|
XCTAssertEqual(error.sql, "This is not SQL")
|
|
} else {
|
|
XCTFail("Unexpected error: \(error)")
|
|
}
|
|
}
|
|
expectation.fulfill()
|
|
})
|
|
semaphore.signal()
|
|
waitForExpectations(timeout: 2, handler: nil)
|
|
}
|
|
|
|
try test(makeDatabaseQueue())
|
|
try test(makeDatabasePool())
|
|
}
|
|
|
|
func testAnyDatabaseWriter() throws {
|
|
// This test passes if this code compiles.
|
|
let dbQueue = try DatabaseQueue()
|
|
let _: any DatabaseWriter = AnyDatabaseWriter(dbQueue)
|
|
}
|
|
|
|
func testEraseAndVacuum() throws {
|
|
try testEraseAndVacuum(writer: makeDatabaseQueue())
|
|
try testEraseAndVacuum(writer: makeDatabasePool())
|
|
}
|
|
|
|
private func testEraseAndVacuum(writer: some DatabaseWriter) throws {
|
|
var migrator = DatabaseMigrator()
|
|
migrator.registerMigration("init") { db in
|
|
// Create a database with recursive constraints, so that we test
|
|
// that those don't prevent database erasure.
|
|
try db.execute(sql: """
|
|
CREATE TABLE t1 (id INTEGER PRIMARY KEY AUTOINCREMENT, b UNIQUE, c REFERENCES t2(id) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED);
|
|
CREATE TABLE t2 (id INTEGER PRIMARY KEY AUTOINCREMENT, b UNIQUE, c REFERENCES t1(id) ON DELETE RESTRICT DEFERRABLE INITIALLY DEFERRED);
|
|
CREATE VIRTUAL TABLE ft USING fts4(content);
|
|
CREATE INDEX i ON t1(c);
|
|
CREATE VIEW v AS SELECT id FROM t1;
|
|
CREATE TRIGGER tr AFTER INSERT ON t1 BEGIN INSERT INTO t2 (id, b, c) VALUES (NEW.c, NEW.b, NEW.id); END;
|
|
INSERT INTO t1 (id, b, c) VALUES (1, 1, 1)
|
|
""")
|
|
}
|
|
|
|
try migrator.migrate(writer)
|
|
|
|
try writer.read { db in
|
|
try XCTAssertTrue(db.tableExists("t1"))
|
|
try XCTAssertTrue(db.tableExists("t2"))
|
|
try XCTAssertTrue(db.tableExists("ft"))
|
|
try XCTAssertTrue(db.viewExists("v"))
|
|
try XCTAssertTrue(db.triggerExists("tr"))
|
|
try XCTAssertEqual(db.indexes(on: "t1").count, 2)
|
|
}
|
|
|
|
try writer.erase()
|
|
try writer.vacuum()
|
|
|
|
try writer.read { db in
|
|
try XCTAssertNil(Row.fetchOne(db, sql: "SELECT * FROM sqlite_master"))
|
|
}
|
|
}
|
|
|
|
func testVacuumInto() throws {
|
|
guard #available(iOS 14, macOS 10.16, tvOS 14, watchOS 7, *) else {
|
|
throw XCTSkip("VACUUM INTO is not available")
|
|
}
|
|
// Prevent SQLCipher failures
|
|
guard sqlite3_libversion_number() >= 3027000 else {
|
|
throw XCTSkip("VACUUM INTO is not available")
|
|
}
|
|
|
|
func testVacuumInto(writer: some DatabaseWriter) throws {
|
|
var migrator = DatabaseMigrator()
|
|
migrator.registerMigration("init") { db in
|
|
try db.execute(sql: """
|
|
CREATE TABLE t1 (id INTEGER PRIMARY KEY AUTOINCREMENT, b, c);
|
|
INSERT INTO t1 (b, c) VALUES (1, 1);
|
|
INSERT INTO t1 (b, c) VALUES (2, 2);
|
|
""")
|
|
}
|
|
|
|
try migrator.migrate(writer)
|
|
|
|
try writer.read { db in
|
|
try XCTAssertTrue(db.tableExists("t1"))
|
|
XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT count(*) from t1"), 2)
|
|
}
|
|
|
|
let intoPath = NSTemporaryDirectory().appending(ProcessInfo.processInfo.globallyUniqueString).appending("-vacuum-into-db.sqlite")
|
|
try writer.vacuum(into: intoPath)
|
|
|
|
// open newly created file and ensure table was copied, and
|
|
// encrypted like the original.
|
|
let newWriter = try DatabaseQueue(path: intoPath, configuration: writer.configuration)
|
|
try newWriter.read { db in
|
|
try XCTAssertTrue(db.tableExists("t1"))
|
|
XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT count(*) from t1"), 2)
|
|
}
|
|
}
|
|
|
|
try testVacuumInto(writer: makeDatabaseQueue())
|
|
try testVacuumInto(writer: makeDatabasePool())
|
|
}
|
|
|
|
// See https://github.com/groue/GRDB.swift/issues/424
|
|
func testIssue424() throws {
|
|
let dbQueue = try makeDatabaseQueue()
|
|
try dbQueue.write { db in
|
|
try db.execute(sql: """
|
|
CREATE TABLE t(a);
|
|
INSERT INTO t VALUES (1)
|
|
""")
|
|
}
|
|
try dbQueue.read { db in
|
|
_ = try Row.fetchCursor(db.cachedStatement(sql: "SELECT * FROM t")).next()
|
|
}
|
|
try dbQueue.erase()
|
|
}
|
|
|
|
// See https://github.com/groue/GRDB.swift/issues/424
|
|
func testIssue424Minimal() throws {
|
|
// SQLCipher can't backup encrypted databases: use a pristine Configuration
|
|
let dbQueue = try makeDatabaseQueue(configuration: Configuration())
|
|
try dbQueue.inDatabase { db in
|
|
try db.execute(sql: """
|
|
CREATE TABLE t(a);
|
|
INSERT INTO t VALUES (1);
|
|
PRAGMA query_only = 1;
|
|
""")
|
|
_ = try Row.fetchCursor(db.cachedStatement(sql: "SELECT * FROM t")).next()
|
|
}
|
|
try DatabaseQueue().backup(to: dbQueue)
|
|
}
|
|
|
|
@available(iOS 13, macOS 10.15, tvOS 13, watchOS 6, *)
|
|
func testAsyncAwait_write() async throws {
|
|
func setup<T: DatabaseWriter>(_ dbWriter: T) throws -> T {
|
|
try dbWriter.write { db in
|
|
try db.execute(sql: "CREATE TABLE t (id INTEGER PRIMARY KEY)")
|
|
}
|
|
return dbWriter
|
|
}
|
|
func test<T: DatabaseWriter>(_ dbWriter: T) async throws {
|
|
let count = try await dbWriter.write { db -> Int in
|
|
try db.execute(sql: "INSERT INTO t DEFAULT VALUES")
|
|
return try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM t")!
|
|
}
|
|
XCTAssertEqual(count, 1)
|
|
}
|
|
|
|
try await test(setup(makeDatabaseQueue()))
|
|
try await test(setup(makeDatabasePool()))
|
|
}
|
|
|
|
@available(iOS 13, macOS 10.15, tvOS 13, watchOS 6, *)
|
|
func testAsyncAwait_writeWithoutTransaction() async throws {
|
|
func setup<T: DatabaseWriter>(_ dbWriter: T) throws -> T {
|
|
try dbWriter.write { db in
|
|
try db.execute(sql: "CREATE TABLE t (id INTEGER PRIMARY KEY)")
|
|
}
|
|
return dbWriter
|
|
}
|
|
func test<T: DatabaseWriter>(_ dbWriter: T) async throws {
|
|
let count = try await dbWriter.writeWithoutTransaction { db -> Int in
|
|
try db.beginTransaction()
|
|
try db.execute(sql: "INSERT INTO t DEFAULT VALUES")
|
|
let count = try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM t")!
|
|
try db.commit()
|
|
return count
|
|
}
|
|
XCTAssertEqual(count, 1)
|
|
}
|
|
|
|
try await test(setup(makeDatabaseQueue()))
|
|
try await test(setup(makeDatabasePool()))
|
|
}
|
|
|
|
@available(iOS 13, macOS 10.15, tvOS 13, watchOS 6, *)
|
|
func testAsyncAwait_barrierWriteWithoutTransaction() async throws {
|
|
func setup<T: DatabaseWriter>(_ dbWriter: T) throws -> T {
|
|
try dbWriter.write { db in
|
|
try db.execute(sql: "CREATE TABLE t (id INTEGER PRIMARY KEY)")
|
|
}
|
|
return dbWriter
|
|
}
|
|
func test<T: DatabaseWriter>(_ dbWriter: T) async throws {
|
|
let count = try await dbWriter.barrierWriteWithoutTransaction { db -> Int in
|
|
try db.beginTransaction()
|
|
try db.execute(sql: "INSERT INTO t DEFAULT VALUES")
|
|
let count = try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM t")!
|
|
try db.commit()
|
|
return count
|
|
}
|
|
XCTAssertEqual(count, 1)
|
|
}
|
|
|
|
try await test(setup(makeDatabaseQueue()))
|
|
try await test(setup(makeDatabasePool()))
|
|
}
|
|
|
|
@available(iOS 13, macOS 10.15, tvOS 13, watchOS 6, *)
|
|
func testAsyncAwait_erase() async throws {
|
|
func setup<T: DatabaseWriter>(_ dbWriter: T) throws -> T {
|
|
try dbWriter.write { db in
|
|
try db.execute(sql: "CREATE TABLE t (id INTEGER PRIMARY KEY)")
|
|
}
|
|
return dbWriter
|
|
}
|
|
func test<T: DatabaseWriter>(_ dbWriter: T) async throws {
|
|
try await dbWriter.erase()
|
|
let tableExists = try await dbWriter.read { try $0.tableExists("t") }
|
|
XCTAssertFalse(tableExists)
|
|
}
|
|
|
|
try await test(setup(makeDatabaseQueue()))
|
|
try await test(setup(makeDatabasePool()))
|
|
}
|
|
|
|
@available(iOS 13, macOS 10.15, tvOS 13, watchOS 6, *)
|
|
func testAsyncAwait_vacuum() async throws {
|
|
func setup<T: DatabaseWriter>(_ dbWriter: T) throws -> T {
|
|
try dbWriter.write { db in
|
|
try db.execute(sql: "CREATE TABLE t (id INTEGER PRIMARY KEY)")
|
|
}
|
|
return dbWriter
|
|
}
|
|
func test<T: DatabaseWriter>(_ dbWriter: T) async throws {
|
|
try await dbWriter.vacuum()
|
|
}
|
|
|
|
try await test(setup(makeDatabaseQueue()))
|
|
try await test(setup(makeDatabasePool()))
|
|
}
|
|
|
|
@available(iOS 14, macOS 10.16, tvOS 14, watchOS 7, *) // async + vacuum into
|
|
func testAsyncAwait_vacuumInto() async throws {
|
|
// Prevent SQLCipher failures
|
|
guard sqlite3_libversion_number() >= 3027000 else {
|
|
throw XCTSkip("VACUUM INTO is not available")
|
|
}
|
|
|
|
func setup<T: DatabaseWriter>(_ dbWriter: T) throws -> T {
|
|
try dbWriter.write { db in
|
|
try db.execute(sql: "CREATE TABLE t (id INTEGER PRIMARY KEY)")
|
|
}
|
|
return dbWriter
|
|
}
|
|
func test<T: DatabaseWriter>(_ dbWriter: T) async throws {
|
|
let intoPath = NSTemporaryDirectory().appending(ProcessInfo.processInfo.globallyUniqueString).appending("-vacuum-into-db.sqlite")
|
|
try await dbWriter.vacuum(into: intoPath)
|
|
do {
|
|
// open newly created file and ensure table was copied, and
|
|
// encrypted like the original.
|
|
let dbQueue = try DatabaseQueue(path: intoPath, configuration: dbWriter.configuration)
|
|
let tableExists = try await dbQueue.read { try $0.tableExists("t") }
|
|
XCTAssertTrue(tableExists)
|
|
}
|
|
try FileManager().removeItem(atPath: intoPath)
|
|
}
|
|
|
|
try await test(setup(makeDatabaseQueue()))
|
|
try await test(setup(makeDatabasePool()))
|
|
}
|
|
|
|
/// A test related to <https://github.com/groue/GRDB.swift/issues/1456>
|
|
@available(iOS 13, macOS 10.15, tvOS 13, watchOS 6, *)
|
|
func testAsyncWriteThenRead() async throws {
|
|
/// An async read performed after an async write should see the write.
|
|
func test(_ dbWriter: some DatabaseWriter) async throws {
|
|
try await dbWriter.write { db in
|
|
try db.execute(sql: """
|
|
CREATE TABLE t (id INTEGER PRIMARY KEY);
|
|
INSERT INTO t VALUES (1);
|
|
""")
|
|
}
|
|
|
|
let count = try await dbWriter.read { db in
|
|
try Table("t").fetchCount(db)
|
|
}
|
|
|
|
XCTAssertEqual(count, 1)
|
|
}
|
|
|
|
try await test(makeDatabaseQueue())
|
|
try await test(makeDatabasePool())
|
|
}
|
|
}
|