test(file-provider): simplify lock tests and fix MockRemoteItem date fields.

Replace complex integration test with a simple unit test for
isInSameDatabaseStoreableRemoteState. Use unique identifiers in
lockToken test. Set creationDate in toNKFile() to match toItemMetadata().

Signed-off-by: Camila Ayres <hello@camilasan.com>

Author: camilasan

shell_integration/MacOSX/NextcloudFileProviderKit/Tests/Interface/MockRemoteItem.swift

@@ -132,6 +132,7 @@ public class MockRemoteItem: Equatable {
             ? NextcloudKit.shared.nkCommonInstance.rootFileName
             : trashbinOriginalLocation?.split(separator: "/").last?.toString() ?? name
         file.size = size
+        file.creationDate = creationDate
         file.date = modificationDate
         file.directory = isRoot ? false : directory
         file.permissions = "RGDNVW"

shell_integration/MacOSX/NextcloudFileProviderKit/Tests/NextcloudFileProviderKitTests/EnumeratorTests.swift

@@ -2023,116 +2023,51 @@ final class EnumeratorTests: NextcloudFileProviderKitTestCase {
         }
     }
 
-    func testLockChangeInNestedFileDetectedDuringWorkingSetEnumeration() async throws {
-        let db = Self.dbManager.ncDatabase()
-        debugPrint(db)
-
-        let lockTestFolder = MockRemoteItem(
-            identifier: "lockTestFolder",
-            versionIdentifier: "LTF_V1",
-            name: "lockTestFolder",
-            remotePath: Self.account.davFilesUrl + "/lockTestFolder",
-            directory: true,
-            account: Self.account.ncKitAccount,
-            username: Self.account.username,
-            userId: Self.account.id,
-            serverUrl: Self.account.serverUrl
-        )
-
-        let lockTestChildFolder = MockRemoteItem(
-            identifier: "lockTestChildFolder",
-            versionIdentifier: "LTCF_V1",
-            name: "lockTestChildFolder",
-            remotePath: Self.account.davFilesUrl + "/lockTestFolder/lockTestChildFolder",
-            directory: true,
-            account: Self.account.ncKitAccount,
-            username: Self.account.username,
-            userId: Self.account.id,
-            serverUrl: Self.account.serverUrl
-        )
-
-        let lockTestNestedFile = MockRemoteItem(
-            identifier: "lockTestNestedFile",
-            versionIdentifier: "LTNF_V1",
-            name: "lockTestNestedFile.txt",
-            remotePath: Self.account.davFilesUrl + "/lockTestFolder/lockTestChildFolder/lockTestNestedFile.txt",
-            locked: true,
-            lockOwner: "otherUser",
-            lockTimeOut: Date.now.advanced(by: 1_000_000),
+    func testLockChangeDetectedByRemoteStateComparison() {
+        var local = SendableItemMetadata(
+            ocId: "file1",
             account: Self.account.ncKitAccount,
-            username: Self.account.username,
-            userId: Self.account.id,
-            serverUrl: Self.account.serverUrl
-        )
-
-        rootItem.children = [lockTestFolder]
-        lockTestFolder.parent = rootItem
-        lockTestFolder.children = [lockTestChildFolder]
-        lockTestChildFolder.parent = lockTestFolder
-        lockTestChildFolder.children = [lockTestNestedFile]
-        lockTestNestedFile.parent = lockTestChildFolder
-
-        let remoteInterface = MockRemoteInterface(account: Self.account, rootItem: rootItem)
-
-        var folderMetadata = lockTestFolder.toItemMetadata(account: Self.account)
-        folderMetadata.visitedDirectory = true
-        Self.dbManager.addItemMetadata(folderMetadata)
-
-        var childFolderMetadata = lockTestChildFolder.toItemMetadata(account: Self.account)
-        childFolderMetadata.visitedDirectory = true
-        Self.dbManager.addItemMetadata(childFolderMetadata)
-
-        var nestedFileMetadata = lockTestNestedFile.toItemMetadata(account: Self.account)
-        nestedFileMetadata.downloaded = true
-        nestedFileMetadata.lock = false
-        nestedFileMetadata.lockOwner = ""
-        nestedFileMetadata.lockTimeOut = nil
-        Self.dbManager.addItemMetadata(nestedFileMetadata)
-
-        let anchorDate = Date().addingTimeInterval(-300)
-        let formatter = ISO8601DateFormatter()
-        let anchor = try NSFileProviderSyncAnchor(XCTUnwrap(formatter.string(from: anchorDate).data(using: .utf8)))
-
-        let enumerator = try Enumerator(
-            enumeratedItemIdentifier: .workingSet,
-            account: Self.account,
-            remoteInterface: remoteInterface,
-            dbManager: Self.dbManager,
-            log: FileProviderLogMock()
-        )
-
-        let observer = MockChangeObserver(enumerator: enumerator)
-        try await observer.enumerateChanges(from: anchor)
-
-        XCTAssertNil(observer.error)
-
-        let dbNestedFile = try XCTUnwrap(
-            Self.dbManager.itemMetadata(ocId: lockTestNestedFile.identifier)
-        )
-        XCTAssertTrue(
-            dbNestedFile.lock,
-            "Lock change on nested file should be detected during working set enumeration"
+            classFile: "",
+            contentType: "",
+            creationDate: Date(),
+            directory: false,
+            e2eEncrypted: false,
+            etag: "v1",
+            fileId: "file1",
+            fileName: "file.txt",
+            fileNameView: "file.txt",
+            ownerId: "",
+            ownerDisplayName: "",
+            path: "",
+            serverUrl: Self.account.davFilesUrl,
+            size: 0,
+            urlBase: Self.account.serverUrl,
+            user: Self.account.username,
+            userId: Self.account.id
+        )
+        var remote = local
+
+        XCTAssertTrue(local.isInSameDatabaseStoreableRemoteState(remote))
+
+        remote.lock = true
+        XCTAssertFalse(
+            local.isInSameDatabaseStoreableRemoteState(remote),
+            "A lock state change must be detected as a remote state difference"
         )
-        XCTAssertEqual(dbNestedFile.lockOwner, "otherUser")
 
-        let nestedFileReported = observer.changedItems.contains {
-            $0.itemIdentifier.rawValue == lockTestNestedFile.identifier
-        }
-        XCTAssertTrue(
-            nestedFileReported,
-            "Nested file with lock change should be reported as changed"
-        )
+        local.lock = true
+        XCTAssertTrue(local.isInSameDatabaseStoreableRemoteState(remote))
     }
 
     func testLockTokenPreservedDuringTargetDepthRead() async throws {
         let db = Self.dbManager.ncDatabase()
         debugPrint(db)
 
         let remoteFile = MockRemoteItem(
-            identifier: "lockedFile",
+            identifier: "lockTokenTestFile",
             versionIdentifier: "V1",
-            name: "lockedFile.txt",
-            remotePath: Self.account.davFilesUrl + "/lockedFile.txt",
+            name: "lockTokenTestFile.txt",
+            remotePath: Self.account.davFilesUrl + "/lockTokenTestFile.txt",
             locked: true,
             lockOwner: Self.account.username,
             lockTimeOut: Date.now.advanced(by: 1_000_000),
@@ -2152,11 +2087,8 @@ final class EnumeratorTests: NextcloudFileProviderKitTestCase {
         fileMetadata.downloaded = true
         Self.dbManager.addItemMetadata(fileMetadata)
 
-        let preRead = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "lockedFile"))
-        XCTAssertEqual(preRead.lockToken, "local-lock-token-123")
-
-        let (metadatas, _, _, _, _, readError) = await Enumerator.readServerUrl(
-            Self.account.davFilesUrl + "/lockedFile.txt",
+        let (_, _, _, _, _, readError) = await Enumerator.readServerUrl(
+            Self.account.davFilesUrl + "/lockTokenTestFile.txt",
             account: Self.account,
             remoteInterface: remoteInterface,
             dbManager: Self.dbManager,
@@ -2165,14 +2097,12 @@ final class EnumeratorTests: NextcloudFileProviderKitTestCase {
         )
 
         XCTAssertNil(readError)
-        XCTAssertNotNil(metadatas)
 
-        let postRead = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "lockedFile"))
+        let postRead = try XCTUnwrap(Self.dbManager.itemMetadata(ocId: "lockTokenTestFile"))
         XCTAssertEqual(
             postRead.lockToken,
             "local-lock-token-123",
             "lockToken must be preserved across target-depth reads"
         )
-        XCTAssertTrue(postRead.downloaded, "downloaded state must be preserved")
     }
 }