Adding FileLock Tests

Author: roulpriya

Sources/SwiftlyCore/FileLock.swift

@@ -1,9 +1,20 @@
 import Foundation
 import SystemPackage
 
-enum FileLockError: Error {
-    case cannotAcquireLock
-    case timeoutExceeded
+enum FileLockError: Error, LocalizedError {
+    case cannotAcquireLock(FilePath)
+    case lockedByPID(FilePath, String?)
+
+    var errorDescription: String? {
+        switch self {
+        case let .cannotAcquireLock(path):
+            return "Cannot acquire lock at \(path). Another process may be holding the lock."
+        case let .lockedByPID(path, pid):
+            let pidDescription = pid ?? "unknown"
+            return
+                "Lock at \(path) is held by process ID \(pidDescription). Wait for the process to complete or manually remove the lock file if the process is no longer running."
+        }
+    }
 }
 
 /// A non-blocking file lock implementation using file creation as locking mechanism.
@@ -19,10 +30,21 @@ public struct FileLock {
         self.filePath = path
         do {
             let fileURL = URL(fileURLWithPath: self.filePath.string)
-            let contents = Foundation.ProcessInfo.processInfo.processIdentifier.description.data(using: .utf8) ?? Data()
+            let contents = Foundation.ProcessInfo.processInfo.processIdentifier.description.data(using: .utf8)
+                ?? Data()
             try contents.write(to: fileURL, options: .withoutOverwriting)
         } catch CocoaError.fileWriteFileExists {
-            throw FileLockError.cannotAcquireLock
+            // Read the PID from the existing lock file
+            let fileURL = URL(fileURLWithPath: self.filePath.string)
+            if let data = try? Data(contentsOf: fileURL),
+               let pidString = String(data: data, encoding: .utf8)?.trimmingCharacters(
+                   in: .whitespacesAndNewlines),
+               !pidString.isEmpty
+            {
+                throw FileLockError.lockedByPID(self.filePath, pidString)
+            } else {
+                throw FileLockError.cannotAcquireLock(self.filePath)
+            }
         }
     }
 
@@ -32,14 +54,29 @@ public struct FileLock {
         pollingInterval: TimeInterval = FileLock.defaultPollingInterval
     ) async throws -> FileLock {
         let start = Date()
+        var lockedByPID: String?
         while Date().timeIntervalSince(start) < timeout {
-            if let fileLock = try? FileLock(at: path) {
+            do {
+                let fileLock = try FileLock(at: path)
                 return fileLock
+            } catch let FileLockError.lockedByPID(_, pid) {
+                lockedByPID = pid
+                if let pidString = pid {
+                    do {
+                        let isRunning = try isProcessRunning(pidString: pidString)
+                        if !isRunning {
+                            // Process is no longer running, remove stale lock file and try again
+                            try? FileManager.default.removeItem(at: URL(fileURLWithPath: path.string))
+                            continue
+                        }
+                    } catch {
+                        throw FileLockError.cannotAcquireLock(path)
+                    }
+                }
+                try? await Task.sleep(for: .seconds(pollingInterval) + .milliseconds(Int.random(in: 0...200)))
             }
-            try? await Task.sleep(for: .seconds(pollingInterval))
         }
-
-        throw FileLockError.timeoutExceeded
+        throw FileLockError.lockedByPID(path, lockedByPID)
     }
 
     public func unlock() async throws {
@@ -53,14 +90,15 @@ public func withLock<T>(
     pollingInterval: TimeInterval = FileLock.defaultPollingInterval,
     action: @escaping () async throws -> T
 ) async throws -> T {
-    guard
-        let lock = try? await FileLock.waitForLock(
+    let lock: FileLock
+    do {
+        lock = try await FileLock.waitForLock(
             lockFile,
             timeout: timeout,
             pollingInterval: pollingInterval
         )
-    else {
-        throw SwiftlyError(message: "Failed to acquire file lock at \(lockFile)")
+    } catch {
+        throw SwiftlyError(message: "Failed to acquire file lock at \(lockFile): \(error.localizedDescription)")
     }
 
     do {

Sources/SwiftlyCore/ProcessInfo.swift

@@ -0,0 +1,56 @@
+import Foundation
+
+#if os(Windows)
+import WinSDK
+#endif
+
+enum ProcessCheckError: Error {
+    case invalidPID
+    case checkFailed
+    case platformNotSupported
+}
+
+/// Checks if a process is still running by process ID
+/// - Parameter pidString: The process ID
+/// - Returns: true if the process is running, false if it's not running or doesn't exist
+/// - Throws: ProcessCheckError if the check fails or PID is invalid
+public func isProcessRunning(pidString: String) throws -> Bool {
+    guard let pid = Int32(pidString.trimmingCharacters(in: .whitespaces)) else {
+        throw ProcessCheckError.invalidPID
+    }
+
+    return try isProcessRunning(pid: pid)
+}
+
+public func isProcessRunning(pid: Int32) throws -> Bool {
+#if os(macOS) || os(Linux)
+    let result = kill(pid, 0)
+    if result == 0 {
+        return true
+    } else if errno == ESRCH { // No such process
+        return false
+    } else if errno == EPERM { // Operation not permitted, but process exists
+        return true
+    } else {
+        throw ProcessCheckError.checkFailed
+    }
+
+#elseif os(Windows)
+    // On Windows, use OpenProcess to check if process exists
+    let handle = OpenProcess(DWORD(PROCESS_QUERY_LIMITED_INFORMATION), false, DWORD(pid))
+    if handle != nil {
+        CloseHandle(handle)
+        return true
+    } else {
+        let error = GetLastError()
+        if error == ERROR_INVALID_PARAMETER || error == ERROR_NOT_FOUND {
+            return false // Process not found
+        } else {
+            throw ProcessCheckError.checkFailed
+        }
+    }
+
+#else
+    throw ProcessCheckError.platformNotSupported
+#endif
+}

Tests/SwiftlyTests/FileLockTests.swift

@@ -0,0 +1,196 @@
+import Foundation
+import SystemPackage
+import Testing
+
+@testable import SwiftlyCore
+
+@Suite struct FileLockTests {
+    @Test("FileLock creation writes process ID to lock file")
+    func testFileLockCreation() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "test.lock"
+
+            let lock = try FileLock(at: lockPath)
+
+            // Verify lock file exists
+            #expect(try await fs.exists(atPath: lockPath))
+
+            // Verify lock file contains process ID
+            let lockData = try Data(contentsOf: URL(fileURLWithPath: lockPath.string))
+            let lockContent = String(data: lockData, encoding: .utf8)
+            let expectedPID = Foundation.ProcessInfo.processInfo.processIdentifier.description
+            #expect(lockContent == expectedPID)
+
+            try await lock.unlock()
+        }
+    }
+
+    @Test("FileLock fails when lock file already exists")
+    func testFileLockConflict() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "conflict.lock"
+
+            // Create first lock
+            let firstLock = try FileLock(at: lockPath)
+
+            // Attempt to create second lock should fail
+            do {
+                _ = try FileLock(at: lockPath)
+                #expect(Bool(false), "Expected FileLockError.lockedByPID to be thrown")
+            } catch let error as FileLockError {
+                if case .lockedByPID = error {
+                } else {
+                    #expect(Bool(false), "Expected FileLockError.lockedByPID but got \(error)")
+                }
+            }
+
+            try await firstLock.unlock()
+        }
+    }
+
+    @Test("FileLock unlock removes lock file")
+    func testFileLockUnlock() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "unlock.lock"
+
+            let lock = try FileLock(at: lockPath)
+            #expect(try await fs.exists(atPath: lockPath))
+
+            try await lock.unlock()
+            #expect(!(try await fs.exists(atPath: lockPath)))
+        }
+    }
+
+    @Test("FileLock can be reacquired after unlock")
+    func testFileLockReacquisition() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "reacquire.lock"
+
+            // First acquisition
+            let firstLock = try FileLock(at: lockPath)
+            try await firstLock.unlock()
+
+            // Second acquisition should succeed
+            let secondLock = try FileLock(at: lockPath)
+            try await secondLock.unlock()
+        }
+    }
+
+    @Test("waitForLock succeeds immediately when no lock exists")
+    func testWaitForLockImmediate() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "immediate.lock"
+            let time = Date()
+            let lock = try await FileLock.waitForLock(lockPath, timeout: 1.0, pollingInterval: 0.1)
+            let duration = Date().timeIntervalSince(time)
+            #expect(duration < 1.0)
+            #expect(try await fs.exists(atPath: lockPath))
+            try await lock.unlock()
+        }
+    }
+
+    @Test("waitForLock times out when lock cannot be acquired")
+    func testWaitForLockTimeout() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "timeout.lock"
+
+            // Create existing lock
+            let existingLock = try FileLock(at: lockPath)
+
+            // Attempt to wait for lock should timeout
+            do {
+                _ = try await FileLock.waitForLock(lockPath, timeout: 0.5, pollingInterval: 0.1)
+                #expect(Bool(false), "Expected FileLockError.lockedByPID to be thrown")
+            } catch let error as FileLockError {
+                if case .lockedByPID = error {
+                    // Expected error
+                } else {
+                    #expect(Bool(false), "Expected FileLockError.lockedByPID but got \(error)")
+                }
+            }
+
+            try await existingLock.unlock()
+        }
+    }
+
+    @Test("waitForLock succeeds when lock becomes available")
+    func testWaitForLockEventualSuccess() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "eventual.lock"
+
+            // Create initial lock
+            let initialLock = try FileLock(at: lockPath)
+            // Start waiting for lock in background task
+            let waitTask = Task {
+                try await Task.sleep(for: .seconds(0.1))
+                let waitingLock = try await FileLock.waitForLock(
+                    lockPath,
+                    timeout: 2.0,
+                    pollingInterval: 0.1
+                )
+                try await waitingLock.unlock()
+                return true
+            }
+            // Release initial lock after delay
+            try await Task.sleep(for: .seconds(0.3))
+            try await initialLock.unlock()
+            // Wait for the waiting task to complete
+            let result = try await waitTask.value
+            #expect(result, "Lock wait operation should succeed")
+        }
+    }
+
+    @Test("withLock executes action and automatically unlocks")
+    func testWithLockSuccess() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "withlock.lock"
+            var actionExecuted = false
+
+            let result = try await withLock(lockPath, timeout: 1.0, pollingInterval: 0.1) {
+                actionExecuted = true
+                return "success"
+            }
+
+            #expect(actionExecuted)
+            #expect(result == "success")
+            #expect(!(try await fs.exists(atPath: lockPath)))
+        }
+    }
+
+    @Test("withLock unlocks even when action throws")
+    func testWithLockErrorHandling() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "withlockError.lock"
+
+            struct TestError: Error {}
+
+            await #expect(throws: TestError.self) {
+                try await withLock(lockPath, timeout: 1.0, pollingInterval: 0.1) {
+                    throw TestError()
+                }
+            }
+
+            // Lock should be released even after error
+            let exists = try await fs.exists(atPath: lockPath)
+            #expect(!exists)
+        }
+    }
+
+    @Test("withLock fails when lock cannot be acquired within timeout")
+    func testWithLockTimeout() async throws {
+        try await SwiftlyTests.withTestHome {
+            let lockPath = SwiftlyTests.ctx.mockedHomeDir! / "withlockTimeout.lock"
+
+            // Create existing lock
+            let existingLock = try FileLock(at: lockPath)
+
+            await #expect(throws: SwiftlyError.self) {
+                try await withLock(lockPath, timeout: 0.5, pollingInterval: 0.1) {
+                    "should not execute"
+                }
+            }
+
+            try await existingLock.unlock()
+        }
+    }
+}