add swiftUI code

2025-01-22 14:09:10 +08:00
parent 68e7b7347c
commit 8a99853829
2531 changed files with 486215 additions and 0 deletions
@@ -0,0 +1,151 @@
+import XCTest
+@testable import GRDB
+
+class BackupTestCase: GRDBTestCase {
+    
+    // A "user" error simply for testing purposes
+    private struct AbandonBackupError: Error {}
+    
+    private func setupBackupSource(_ writer: some DatabaseWriter) throws -> Int {
+        try writer.write { db in
+            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
+            try db.execute(sql: "INSERT INTO items (id) VALUES (0)")
+        }
+        
+        let pageCount: Int = try writer.read { db in
+            try Int.fetchOne(db, sql: "PRAGMA page_count")!
+        }
+        
+        // pageCount must be greater than 1 to allow for incremental backup testing
+        XCTAssertGreaterThan(pageCount, 1)
+        
+        return pageCount
+    }
+    
+    private func setupBackupDestination(_ writer: some DatabaseWriter) throws {
+        try writer.write { db in
+            try db.execute(sql: "CREATE TABLE items (id INTEGER PRIMARY KEY)")
+            try db.execute(sql: "INSERT INTO items (id) VALUES (1)")
+        }
+    }
+    
+    func testDatabaseWriterBackup(from source: some DatabaseWriter, to destination: some DatabaseWriter) throws {
+        let sourceDbPageCount = try setupBackupSource(source)
+        try setupBackupDestination(destination)
+
+        XCTAssertThrowsError(
+            try source.backup(to: destination, pagesPerStep: 1) { progress in
+                XCTAssertLessThan(progress.completedPageCount, progress.totalPageCount)
+                XCTAssertFalse(progress.isCompleted)
+                throw AbandonBackupError()
+            }
+        )
+
+        try destination.read { db in
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT id FROM items")!, 1)
+        }
+
+        var progressCount: Int = 1
+        var isCompleted: Bool = false
+        try source.backup(to: destination, pagesPerStep: 1) { progress in
+            let expectedCompletedPages = progressCount
+            XCTAssertEqual(expectedCompletedPages, progress.completedPageCount)
+            if progress.completedPageCount != progress.totalPageCount {
+                progressCount += 1
+            }
+            if progress.isCompleted {
+                isCompleted = true
+                // Should not re-throw
+                throw AbandonBackupError()
+            }
+        }
+        
+        XCTAssertEqual(sourceDbPageCount, progressCount)
+        XCTAssertTrue(isCompleted)
+        
+        try destination.read { db in
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT id FROM items")!, 0)
+        }
+        
+        try source.write { db in
+            try db.execute(sql: "DROP TABLE items")
+        }
+        
+        try source.backup(to: destination)
+        
+        try destination.read { db in
+            XCTAssertFalse(try db.tableExists("items"))
+        }
+    }
+    
+    func testDatabaseBackup(from source: some DatabaseWriter, to destination: some DatabaseWriter) throws {
+        let sourceDbPageCount = try setupBackupSource(source)
+        try setupBackupDestination(destination)
+
+        try source.write { sourceDb in
+            try destination.barrierWriteWithoutTransaction { destDb in
+                XCTAssertThrowsError(
+                    try sourceDb.backup(to: destDb, pagesPerStep: 1) { progress in
+                        XCTAssertLessThan(progress.completedPageCount, progress.totalPageCount)
+                        throw AbandonBackupError()
+                    }
+                )
+            }
+        }
+
+        // Assert that the items table is as it was before the backup was abandoned.
+        // Is this a valid assertion?
+        try destination.read { db in
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT id FROM items")!, 1)
+        }
+
+        try source.write { dbSource in
+            try destination.barrierWriteWithoutTransaction { dbDest in
+                var progressCount: Int = 1
+                var isCompleted: Bool = false
+                try dbSource.backup(to: dbDest, pagesPerStep: 1) { progress in
+                    let expectedCompletedPages = progressCount
+                    XCTAssertEqual(expectedCompletedPages, progress.completedPageCount)
+                    if progress.completedPageCount != progress.totalPageCount {
+                        progressCount += 1
+                    }
+                    if progress.isCompleted {
+                        isCompleted = true
+                        // Should not re-throw
+                        throw AbandonBackupError()
+                    }
+                }
+                
+                XCTAssertEqual(sourceDbPageCount, progressCount)
+                XCTAssertTrue(isCompleted)
+            }
+        }
+        
+        try destination.read { db in
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT COUNT(*) FROM items")!, 1)
+            XCTAssertEqual(try Int.fetchOne(db, sql: "SELECT id FROM items")!, 0)
+        }
+        
+        try source.write { db in
+            try db.execute(sql: "DROP TABLE items")
+        }
+        
+        try source.backup(to: destination)
+        
+        try destination.read { db in
+            XCTAssertFalse(try db.tableExists("items"))
+        }
+    }
+    
+    // Test passes if it compiles.
+    // See <https://github.com/groue/GRDB.swift/issues/1541>
+    func testBackupToAnyDatabaseWriter(
+        _ reader: some DatabaseReader,
+        destination: any DatabaseWriter
+    ) throws {
+        try reader.backup(to: destination)
+    }
+}