Fix pCloud eventual consistency issues in createFolder, moveFile, moveFolder, uploadFile

Replace path-based checkForItemExistence with parent-based name collision
detection that checks both files and folders. This prevents pCloud from
creating a folder with the same name as an existing file (which pCloud
uniquely allows). Add consistency barrier to pCloud integration tests
to wait for listFolder API to catch up after setup.

Author: tobihagemann

Sources/CryptomatorCloudAccess/PCloud/PCloudCloudProvider.swift

@@ -54,28 +54,36 @@ public class PCloudCloudProvider: CloudProvider {
 		if isDirectory.boolValue {
 			return Promise(CloudProviderError.itemTypeMismatch)
 		}
-		return fetchItemMetadata(at: cloudPath).then { metadata -> Void in
-			if !replaceExisting || (replaceExisting && metadata.itemType == .folder) {
-				throw CloudProviderError.itemAlreadyExists
-			}
-		}.recover { error -> Void in
-			guard case CloudProviderError.itemNotFound = error else {
-				throw error
+		return resolveParentPath(forItemAt: cloudPath).then { parentItem -> Promise<PCloudItem> in
+			let targetName = cloudPath.lastPathComponent
+			return self.client.listFolder(parentItem.identifier, recursively: false).execute().then { metadata -> PCloudItem in
+				let existingContent = metadata.contents.first(where: { $0.fileMetadata?.name == targetName || $0.folderMetadata?.name == targetName })
+				if let existingContent = existingContent {
+					if !replaceExisting || existingContent.folderMetadata != nil {
+						throw CloudProviderError.itemAlreadyExists
+					}
+				}
+				return parentItem
+			}.recover { error -> PCloudItem in
+				guard let error = error as? CallError<PCloudAPI.ListFolder.Error> else {
+					throw error
+				}
+				if case CallError.methodError(.folderDoesNotExist) = error {
+					throw CloudProviderError.parentFolderDoesNotExist
+				} else {
+					throw error
+				}
 			}
-		}.then { _ -> Promise<PCloudItem> in
-			return self.resolveParentPath(forItemAt: cloudPath)
 		}.then { parentItem in
 			return self.uploadFile(for: parentItem, from: localURL, to: cloudPath)
 		}
 	}
 
 	public func createFolder(at cloudPath: CloudPath) -> Promise<Void> {
-		return checkForItemExistence(at: cloudPath).then { itemExists -> Void in
-			if itemExists {
-				throw CloudProviderError.itemAlreadyExists
+		return resolveParentPath(forItemAt: cloudPath).then { parentItem -> Promise<PCloudItem> in
+			return self.checkForNameCollision(cloudPath.lastPathComponent, inFolder: parentItem).then {
+				return parentItem
 			}
-		}.then {
-			self.resolveParentPath(forItemAt: cloudPath)
 		}.then { parentItem in
 			return self.createFolder(for: parentItem, with: cloudPath.lastPathComponent)
 		}
@@ -94,26 +102,14 @@ public class PCloudCloudProvider: CloudProvider {
 	}
 
 	public func moveFile(from sourceCloudPath: CloudPath, to targetCloudPath: CloudPath) -> Promise<Void> {
-		return checkForItemExistence(at: targetCloudPath).then { itemExists -> Void in
-			if itemExists {
-				throw CloudProviderError.itemAlreadyExists
-			}
-		}.then {
-			return all(self.resolvePath(forItemAt: sourceCloudPath), self.resolveParentPath(forItemAt: targetCloudPath))
-		}.then { item, targetParentItem in
-			return self.moveFile(from: item, toParent: targetParentItem, targetCloudPath: targetCloudPath)
+		return resolveForMove(from: sourceCloudPath, to: targetCloudPath).then { sourceItem, targetParentItem in
+			return self.moveFile(from: sourceItem, toParent: targetParentItem, targetCloudPath: targetCloudPath)
 		}
 	}
 
 	public func moveFolder(from sourceCloudPath: CloudPath, to targetCloudPath: CloudPath) -> Promise<Void> {
-		return checkForItemExistence(at: targetCloudPath).then { itemExists -> Void in
-			if itemExists {
-				throw CloudProviderError.itemAlreadyExists
-			}
-		}.then {
-			return all(self.resolvePath(forItemAt: sourceCloudPath), self.resolveParentPath(forItemAt: targetCloudPath))
-		}.then { item, targetParentItem in
-			return self.moveFolder(from: item, toParent: targetParentItem, targetCloudPath: targetCloudPath)
+		return resolveForMove(from: sourceCloudPath, to: targetCloudPath).then { sourceItem, targetParentItem in
+			return self.moveFolder(from: sourceItem, toParent: targetParentItem, targetCloudPath: targetCloudPath)
 		}
 	}
 
@@ -405,6 +401,15 @@ public class PCloudCloudProvider: CloudProvider {
 		return Promise(item)
 	}
 
+	private func resolveForMove(from sourceCloudPath: CloudPath, to targetCloudPath: CloudPath) -> Promise<(PCloudItem, PCloudItem)> {
+		return resolveParentPath(forItemAt: targetCloudPath).then { targetParentItem -> Promise<(PCloudItem, PCloudItem)> in
+			return all(
+				self.checkForNameCollision(targetCloudPath.lastPathComponent, inFolder: targetParentItem).then { targetParentItem },
+				self.resolvePath(forItemAt: sourceCloudPath)
+			)
+		}
+	}
+
 	private func resolveParentPath(forItemAt cloudPath: CloudPath) -> Promise<PCloudItem> {
 		let parentCloudPath = cloudPath.deletingLastPathComponent()
 		return resolvePath(forItemAt: parentCloudPath).recover { error -> PCloudItem in
@@ -456,6 +461,23 @@ public class PCloudCloudProvider: CloudProvider {
 
 	// MARK: - Helpers
 
+	private func checkForNameCollision(_ name: String, inFolder parentItem: PCloudItem) -> Promise<Void> {
+		return client.listFolder(parentItem.identifier, recursively: false).execute().then { metadata -> Void in
+			if metadata.contents.contains(where: { $0.fileMetadata?.name == name || $0.folderMetadata?.name == name }) {
+				throw CloudProviderError.itemAlreadyExists
+			}
+		}.recover { error -> Void in
+			guard let error = error as? CallError<PCloudAPI.ListFolder.Error> else {
+				throw error
+			}
+			if case CallError.methodError(.folderDoesNotExist) = error {
+				throw CloudProviderError.parentFolderDoesNotExist
+			} else {
+				throw error
+			}
+		}
+	}
+
 	private func convertToCloudItemMetadata(_ content: Content, at cloudPath: CloudPath) throws -> CloudItemMetadata {
 		if let fileMetadata = content.fileMetadata {
 			return convertToCloudItemMetadata(fileMetadata, at: cloudPath)

Tests/CryptomatorCloudAccessIntegrationTests/PCloud/PCloudCloudProviderIntegrationTests.swift

@@ -12,8 +12,8 @@ import CryptomatorCloudAccessCore
 import CryptomatorCloudAccess
 #endif
 import PCloudSDKSwift
-import Promises
 import XCTest
+@testable import Promises
 
 class PCloudCloudProviderIntegrationTests: CloudAccessIntegrationTestWithAuthentication {
 	override class var defaultTestSuite: XCTestSuite {
@@ -29,6 +29,25 @@ class PCloudCloudProviderIntegrationTests: CloudAccessIntegrationTestWithAuthent
 		// swiftlint:disable:next force_try
 		setUpProvider = try! PCloudCloudProvider(client: client)
 		super.setUp()
+		guard classSetUpError == nil else { return }
+		// Wait for pCloud's eventual consistency to catch up after setUp uploaded all test fixtures.
+		let expectedItemCount = 6 // 5 files (test 0-4.txt) + 1 folder (testFolder)
+		_ = waitForConsistency(provider: setUpProvider, folderPath: integrationTestRootCloudPath, expectedItemCount: expectedItemCount)
+		guard waitForPromises(timeout: 60.0) else {
+			classSetUpError = IntegrationTestError.oneTimeSetUpTimeout
+			return
+		}
+	}
+
+	private static func waitForConsistency(provider: CloudProvider, folderPath: CloudPath, expectedItemCount: Int, attempt: Int = 0) -> Promise<Void> {
+		return provider.fetchItemList(forFolderAt: folderPath, withPageToken: nil).then { itemList -> Promise<Void> in
+			if itemList.items.count >= expectedItemCount || attempt >= 10 {
+				return Promise(())
+			}
+			return Promise(()).delay(1.0).then {
+				return waitForConsistency(provider: provider, folderPath: folderPath, expectedItemCount: expectedItemCount, attempt: attempt + 1)
+			}
+		}
 	}
 
 	override func setUpWithError() throws {