Adding FileLock Tests

Author: roulpriya

Sources/SwiftlyCore/FileLock.swift

@@ -2,8 +2,18 @@ import Foundation
 import SystemPackage
 
 enum FileLockError: Error {
-    case cannotAcquireLock
-    case timeoutExceeded
+    case cannotAcquireLock(FilePath)
+    case lockedByPID(FilePath, String?)
+
+    var localizedDescription: 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):
+            return
+                "Lock at \(path) is held by process ID \(pid). 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 +29,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)
+            let pid: String?
+            if let data = try? Data(contentsOf: fileURL),
+               let pidString = String(data: data, encoding: .utf8)?.trimmingCharacters(
+                   in: .whitespacesAndNewlines),
+               !pidString.isEmpty
+            {
+                pid = pidString
+            }
+            throw FileLockError.lockedByPID(path, pid)
         }
     }
 
@@ -32,14 +53,27 @@ 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
+                do {
+                    let isRunning = try isProcessRunning(pidString: pid)
+                    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))
             }
-            try? await Task.sleep(for: .seconds(pollingInterval))
+            throw FileLockError.lockedByPID(path, lockedByPID)
         }
-
-        throw FileLockError.timeoutExceeded
     }
 
     public func unlock() async throws {
@@ -53,14 +87,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 {

Tests/SwiftlyTests/FileLockTests.swift

@@ -0,0 +1,190 @@
+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)
+
+            // Task to release lock after delay
+            let releaseTask = Task {
+                try await Task.sleep(for: .seconds(0.3))
+                try await initialLock.unlock()
+            }
+
+            // Wait for lock - should succeed after release
+            let waitingLock = try await FileLock.waitForLock(lockPath, timeout: 1.0, pollingInterval: 0.1)
+            try await waitingLock.unlock()
+            try await releaseTask.value
+        }
+    }
+
+    @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()
+        }
+    }
+}