Adding FileLock Tests

roulpriya · roulpriya · commit f4c28a4ed995 · 2025-05-29T16:30:33.000+05:30
diff --git a/Sources/SwiftlyCore/FileLock.swift b/Sources/SwiftlyCore/FileLock.swift
@@ -1,9 +1,19 @@
 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. If you are sure no other processes are running, you can manually remove the lock file at \(path)."
+        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)
+            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 +53,33 @@ 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) {
-                return fileLock
+            do {
+                return try FileLock(at: path)
+            } 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) + .milliseconds(Int.random(in: 0...200)))
             }
-            try? await Task.sleep(for: .seconds(pollingInterval))
         }
 
-        throw FileLockError.timeoutExceeded
+        // Timeout reached, throw an error
+        if let lockedByPID = lockedByPID {
+            throw FileLockError.lockedByPID(path, lockedByPID)
+        } else {
+            throw FileLockError.cannotAcquireLock(path)
+        }
     }
 
     public func unlock() async throws {
@@ -53,14 +93,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 {
diff --git a/Sources/SwiftlyCore/ProcessInfo.swift b/Sources/SwiftlyCore/ProcessInfo.swift
@@ -0,0 +1,55 @@
+import Foundation
+
+#if os(Windows)
+import WinSDK
+#endif
+
+enum ProcessCheckError: Error {
+    case invalidPID
+    case checkFailed
+}
+
+/// 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
+    #error("Platform is not supported")
+#endif
+}
diff --git a/Tests/SwiftlyTests/FileLockTests.swift b/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()
+        }
+    }
+}
