Refactor progress file parsing and improve test validation

Author: roulpriya

Sources/Swiftly/JsonFileProgressReporter.swift

@@ -31,14 +31,15 @@ struct JsonFileProgressReporter: ProgressAnimationProtocol {
             return
         }
 
-        self.fileHandle.seekToEndOfFile()
         self.fileHandle.write(jsonData)
         self.fileHandle.write("\n".data(using: .utf8) ?? Data())
-        self.fileHandle.synchronizeFile()
+        try? self.fileHandle.synchronize()
     }
 
     func update(step: Int, total: Int, text: String) {
-        assert(step <= total)
+        guard total > 0 && step <= total else {
+            return
+        }
         self.writeProgress(
             ProgressInfo.step(
                 timestamp: Date(),
@@ -52,8 +53,7 @@ struct JsonFileProgressReporter: ProgressAnimationProtocol {
     }
 
     func clear() {
-        self.fileHandle.truncateFile(atOffset: 0)
-        self.fileHandle.synchronizeFile()
+        // not implemented for JSON file reporter
     }
 
     func close() throws {

Sources/SwiftlyCore/FileManager+FilePath.swift

@@ -190,13 +190,6 @@ extension String {
         try self.write(to: URL(fileURLWithPath: path.string), atomically: atomically, encoding: enc)
     }
 
-    public func append(to path: FilePath, encoding enc: String.Encoding = .utf8) throws {
-        if !FileManager.default.fileExists(atPath: path.string) {
-            try self.write(to: path, atomically: true, encoding: enc)
-            return
-        }
-    }
-
     public init(contentsOf path: FilePath, encoding enc: String.Encoding = .utf8) throws {
         try self.init(contentsOf: URL(fileURLWithPath: path.string), encoding: enc)
     }

Tests/SwiftlyTests/InstallTests.swift

@@ -267,6 +267,7 @@ import Testing
     /// Verify that progress information is written to the progress file when specified.
     @Test(.testHomeMockedToolchain()) func installProgressFile() async throws {
         let progressFile = fs.mktemp(ext: ".json")
+        try await fs.create(.mode(0o644), file: progressFile)
 
         try await SwiftlyTests.runCommand(Install.self, [
             "install", "5.7.0",
@@ -276,24 +277,120 @@ import Testing
 
         #expect(try await fs.exists(atPath: progressFile))
 
+        let decoder = JSONDecoder()
         let progressContent = try String(contentsOfFile: progressFile.string)
-        let lines = progressContent.components(separatedBy: .newlines).filter { !$0.isEmpty }
+        let progressInfo = try progressContent.split(separator: "\n")
+            .filter { !$0.isEmpty }
+            .map { line in
+                try decoder.decode(ProgressInfo.self, from: Data(line.utf8))
+            }
 
-        #expect(!lines.isEmpty, "Progress file should contain progress entries")
+        #expect(!progressInfo.isEmpty, "Progress file should contain progress entries")
 
-        // Verify that at least one progress entry exists
-        let hasProgressEntry = lines.contains { line in
-            line.contains("\"step\"") && line.contains("\"percent\"") && line.contains("\"timestamp\"")
+        // Verify that at least one step progress entry exists
+        let hasStepEntry = progressInfo.contains { info in
+            if case .step = info { return true }
+            return false
         }
-        #expect(hasProgressEntry, "Progress file should contain step progress entries")
+        #expect(hasStepEntry, "Progress file should contain step progress entries")
 
         // Verify that a completion entry exists
-        let hasCompletionEntry = lines.contains { line in
-            line.contains("\"complete\"") && line.contains("\"success\"")
+        let hasCompletionEntry = progressInfo.contains { info in
+            if case .complete = info { return true }
+            return false
         }
         #expect(hasCompletionEntry, "Progress file should contain completion entry")
 
         // Clean up
         try FileManager.default.removeItem(atPath: progressFile.string)
     }
+
+#if os(Linux) || os(macOS)
+    @Test(.testHomeMockedToolchain())
+    func installProgressFileNamedPipe() async throws {
+#if os(Linux) || os(macOS)
+        let tempDir = NSTemporaryDirectory()
+        let pipePath = tempDir + "swiftly_install_progress_pipe"
+
+        let result = mkfifo(pipePath, 0o644)
+        guard result == 0 else {
+            return // Skip test if mkfifo syscall failed
+        }
+
+        defer {
+            try? FileManager.default.removeItem(atPath: pipePath)
+        }
+
+        var receivedMessages: [ProgressInfo] = []
+        let decoder = JSONDecoder()
+        var installCompleted = false
+
+        let readerTask = Task {
+            guard let fileHandle = FileHandle(forReadingAtPath: pipePath) else { return }
+            defer { fileHandle.closeFile() }
+
+            var buffer = Data()
+
+            while !installCompleted {
+                let data = fileHandle.availableData
+                if data.isEmpty {
+                    try await Task.sleep(nanoseconds: 100_000_000)
+                    continue
+                }
+
+                buffer.append(data)
+
+                while let newlineRange = buffer.range(of: "\n".data(using: .utf8)!) {
+                    let lineData = buffer.subdata(in: 0..<newlineRange.lowerBound)
+                    buffer.removeSubrange(0..<newlineRange.upperBound)
+
+                    if !lineData.isEmpty {
+                        if let progress = try? decoder.decode(ProgressInfo.self, from: lineData) {
+                            receivedMessages.append(progress)
+                            if case .complete = progress {
+                                installCompleted = true
+                                return
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        let installTask = Task {
+            try await SwiftlyTests.runCommand(Install.self, [
+                "install", "5.7.0",
+                "--post-install-file=\(fs.mktemp())",
+                "--progress-file=\(pipePath)",
+            ])
+        }
+
+        await withTaskGroup(of: Void.self) { group in
+            group.addTask { try? await readerTask.value }
+            group.addTask { try? await installTask.value }
+        }
+
+        try await Task.sleep(nanoseconds: 100_000_000) // 100ms
+
+        #expect(!receivedMessages.isEmpty, "Named pipe should receive progress entries")
+
+        let hasCompletionEntry = receivedMessages.contains { info in
+            if case .complete = info { return true }
+            return false
+        }
+        #expect(hasCompletionEntry, "Named pipe should receive completion entry")
+
+        for message in receivedMessages {
+            switch message {
+            case let .step(timestamp, percent, text):
+                #expect(timestamp.timeIntervalSince1970 > 0)
+                #expect(percent >= 0 && percent <= 100)
+                #expect(!text.isEmpty)
+            case let .complete(success):
+                #expect(success == true)
+            }
+        }
+#endif
+    }
+#endif
 }

Tests/SwiftlyTests/JsonFileProgressReporterTests.swift

@@ -100,23 +100,6 @@ import Testing
         try FileManager.default.removeItem(atPath: tempFile.string)
     }
 
-    @Test("Test clear method truncates the file")
-    func testClearTruncatesFile() async throws {
-        let tempFile = fs.mktemp(ext: ".json")
-        try await fs.create(.mode(Int(0o644)), file: tempFile)
-        defer { try? FileManager.default.removeItem(atPath: tempFile.string) }
-        let reporter = try JsonFileProgressReporter(SwiftlyTests.ctx, filePath: tempFile)
-        defer { try? reporter.close() }
-
-        reporter.update(step: 1, total: 2, text: "Test")
-
-        #expect(try String(contentsOf: tempFile).lengthOfBytes(using: String.Encoding.utf8) > 0)
-
-        reporter.clear()
-
-        #expect(try String(contentsOf: tempFile).lengthOfBytes(using: String.Encoding.utf8) == 0)
-    }
-
     @Test("Test multiple progress updates create multiple lines")
     func testMultipleUpdatesCreateMultipleLines() async throws {
         let tempFile = fs.mktemp(ext: ".json")