catalyst-core 1.0.0 → 1.0.1-canary.2

package/dist/native/iosnativeWebView/CoreLogic/Tests/CatalystCoreLogicTests/FrameworkServerUtilsConnectionHandlerTests.swift

@@ -0,0 +1,133 @@
+import XCTest
+import Foundation
+import Network
+@testable import CatalystCoreLogic
+
+/**
+ * Deterministic tests for FrameworkServerUtils' connection error paths.
+ *
+ * Whether Network.framework reports a dropped client as a `.failed` connection
+ * state, a receive error, or a send error is timing-dependent, so driving them
+ * with real sockets made the CoreLogic line-coverage number vary from run to
+ * run and turned the coverage-regression gate into a coin flip. These tests
+ * call the extracted handlers directly with synthetic errors so every branch
+ * runs every time.
+ */
+final class FrameworkServerUtilsConnectionHandlerTests: XCTestCase {
+
+    private var frameworkServer: FrameworkServerUtils!
+
+    /// A connection to a closed loopback port (discard, 9). It never carries data;
+    /// it only needs to be startable so that cancel() is observable as `.cancelled`.
+    private func makeIdleConnection() -> NWConnection {
+        NWConnection(host: "127.0.0.1", port: 9, using: .tcp)
+    }
+
+    /// Starts a connection, runs `action` on it, and asserts it ends up `.cancelled`.
+    private func assertCancelled(
+        by action: (NWConnection) -> Void,
+        file: StaticString = #filePath,
+        line: UInt = #line
+    ) {
+        let connection = makeIdleConnection()
+        let cancelled = expectation(description: "connection cancelled")
+        connection.stateUpdateHandler = { state in
+            if case .cancelled = state { cancelled.fulfill() }
+        }
+        connection.start(queue: .global(qos: .utility))
+
+        action(connection)
+
+        wait(for: [cancelled], timeout: 5)
+    }
+
+    override func setUp() {
+        super.setUp()
+        frameworkServer = FrameworkServerUtils.shared
+    }
+
+    override func tearDown() {
+        if frameworkServer.isRunning() {
+            frameworkServer.stopServer()
+        }
+        frameworkServer = nil
+        super.tearDown()
+    }
+
+    func testConnectionStateFailed_CancelsConnection() {
+        assertCancelled { connection in
+            frameworkServer.handleConnectionStateChange(.failed(.posix(.ECONNRESET)), on: connection)
+        }
+    }
+
+    func testConnectionStateCancelled_DoesNotThrowForUntrackedConnection() {
+        let connection = makeIdleConnection()
+
+        frameworkServer.handleConnectionStateChange(.cancelled, on: connection)
+
+        XCTAssertEqual(frameworkServer.activeConnectionCount(), 0)
+    }
+
+    func testConnectionStateWaiting_IsIgnored() {
+        let connection = makeIdleConnection()
+
+        frameworkServer.handleConnectionStateChange(.waiting(.posix(.ENETDOWN)), on: connection)
+
+        XCTAssertNotEqual(connection.state, .cancelled)
+        connection.cancel()
+    }
+
+    func testReceiveError_CancelsConnection() {
+        assertCancelled { connection in
+            frameworkServer.handleReceiveError(.posix(.ECONNRESET), on: connection)
+        }
+    }
+
+    func testReceivedData_WithError_CancelsConnection() {
+        assertCancelled { connection in
+            frameworkServer.handleReceivedData(nil, isComplete: false, error: .posix(.ECONNRESET), on: connection)
+        }
+    }
+
+    func testSendCompletion_WithError_CancelsConnection() {
+        assertCancelled { connection in
+            frameworkServer.handleSendCompletion(.posix(.EPIPE), on: connection)
+        }
+    }
+
+    func testSendCompletion_WithoutError_CancelsConnection() {
+        assertCancelled { connection in
+            frameworkServer.handleSendCompletion(nil, on: connection)
+        }
+    }
+
+    // MARK: - Port selection
+
+    /// findAvailablePort() must skip a port that is already bound. Which ports
+    /// are busy on a CI runner is environmental, so the skip path only ran
+    /// sometimes; occupying the first port in the range makes it run every time.
+    func testStartServer_SkipsOccupiedPort() throws {
+        let firstPort = FrameworkServerUtils.FRAMEWORK_PORT_RANGE_START
+
+        let blocker = socket(AF_INET, SOCK_STREAM, 0)
+        try XCTSkipIf(blocker == -1, "could not create blocker socket")
+        defer { close(blocker) }
+
+        var addr = sockaddr_in()
+        addr.sin_family = sa_family_t(AF_INET)
+        addr.sin_port = firstPort.bigEndian
+        addr.sin_addr.s_addr = INADDR_ANY
+        let bound = withUnsafePointer(to: &addr) {
+            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
+                Darwin.bind(blocker, $0, socklen_t(MemoryLayout<sockaddr_in>.size))
+            }
+        }
+        // bind() failing means another process already holds the first port,
+        // which exercises the same skip path, so the assertions below still hold.
+        _ = bound
+
+        XCTAssertTrue(frameworkServer.startServer())
+        XCTAssertNotEqual(frameworkServer.getServerPort(), firstPort)
+        XCTAssertGreaterThan(frameworkServer.getServerPort(), firstPort)
+    }
+}

package/dist/native/iosnativeWebView/CoreLogic/Tests/CatalystCoreLogicTests/FrameworkServerUtilsLoopbackTests.swift

@@ -2,6 +2,13 @@ import XCTest
 import Foundation
 @testable import CatalystCoreLogic
 
+/// Thrown on CI when the loopback server never becomes reachable, so the test
+/// fails instead of silently skipping and dropping coverage.
+private struct LoopbackServerUnavailable: Error, CustomStringConvertible {
+    let message: String
+    var description: String { message }
+}
+
 /**
  * In-process loopback HTTP tests for FrameworkServerUtils.
  *
@@ -18,10 +25,10 @@ import Foundation
  * math showed 95% package-wide wasn't reachable while FrameworkServerUtils
  * stayed at ~35%.
  *
- * Same "server may not start in this sandbox" guard as the existing test
- * file — network restrictions in some CI/sandbox environments can prevent
- * NWListener from binding. Tests skip (not fail) in that case, consistent
- * with the established pattern.
+ * Each test waits for the listener to accept connections before sending a
+ * request (see requireRunningServer). Outside CI, a sandbox that cannot bind
+ * skips the test; on CI an unavailable server fails it, so loopback coverage
+ * can never silently drop and skew the coverage-regression baseline.
  */
 final class FrameworkServerUtilsLoopbackTests: XCTestCase {
 
@@ -39,22 +46,69 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
         }
         tempFileURL = nil
 
-        if frameworkServer.isRunning() {
-            frameworkServer.stopServer()
-        }
+        // Unconditional: a listener that failed asynchronously reports
+        // isRunning() == false but still holds its timer and listener, which
+        // must not leak into later tests.
+        frameworkServer.stopServer()
         frameworkServer = nil
         super.tearDown()
     }
 
-    /// Starts the server and waits for NWListener's async stateUpdateHandler
-    /// to settle, mirroring the pattern already established in
-    /// FrameworkServerUtilsTests.swift. Returns false (and the caller should
-    /// skip) if the server isn't actually running afterward.
-    private func startServerAndWaitReady() -> Bool {
-        let started = frameworkServer.startServer()
-        guard started else { return false }
-        Thread.sleep(forTimeInterval: 0.3)
-        return frameworkServer.isRunning()
+    /// Starts the server and blocks until it is actually accepting TCP
+    /// connections, so no test sends a request before NWListener is `.ready`.
+    ///
+    /// NWListener reports readiness asynchronously and `startServer()` returns
+    /// before it settles, so a fixed sleep is a race that loses on slow CI
+    /// runners. Instead this polls a raw loopback connect until it succeeds or
+    /// `readinessTimeout` elapses.
+    ///
+    /// If the server never comes up: on CI (`CI` env var set) the test fails,
+    /// because a silent skip would drop the loopback coverage and make the
+    /// coverage baseline non-deterministic. Outside CI (e.g. a restricted local
+    /// sandbox that cannot bind) it skips, as before.
+    private func requireRunningServer() throws {
+        let readinessTimeout: TimeInterval = 10
+
+        guard frameworkServer.startServer() else {
+            try serverUnavailable("startServer() returned false")
+            return
+        }
+
+        let deadline = Date().addingTimeInterval(readinessTimeout)
+        while Date() < deadline {
+            if frameworkServer.isRunning(),
+               Self.canConnect(toLoopbackPort: frameworkServer.getServerPort()) {
+                return
+            }
+            Thread.sleep(forTimeInterval: 0.02)
+        }
+        try serverUnavailable("not accepting connections within \(Int(readinessTimeout))s")
+    }
+
+    private func serverUnavailable(_ reason: String) throws {
+        let message = "Loopback server unavailable: \(reason)"
+        if ProcessInfo.processInfo.environment["CI"] != nil {
+            throw LoopbackServerUnavailable(message: message)
+        }
+        throw XCTSkip("\(message) — skipping loopback test outside CI")
+    }
+
+    private static func canConnect(toLoopbackPort port: UInt16) -> Bool {
+        let fd = socket(AF_INET, SOCK_STREAM, 0)
+        guard fd != -1 else { return false }
+        defer { close(fd) }
+
+        var addr = sockaddr_in()
+        addr.sin_family = sa_family_t(AF_INET)
+        addr.sin_port = port.bigEndian
+        addr.sin_addr.s_addr = inet_addr("127.0.0.1")
+
+        let result = withUnsafePointer(to: &addr) {
+            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
+                connect(fd, $0, socklen_t(MemoryLayout<sockaddr_in>.size))
+            }
+        }
+        return result == 0
     }
 
     private func serveTemporaryFile(content: String, fileName: String, mimeType: String) throws -> String? {
@@ -79,12 +133,89 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
         return (httpResponse, data)
     }
 
+    /// Opens a raw TCP client to the running server and returns its fd.
+    private func openRawClient() throws -> Int32 {
+        let fd = socket(AF_INET, SOCK_STREAM, 0)
+        try XCTSkipIf(fd == -1, "could not create client socket")
+
+        var addr = sockaddr_in()
+        addr.sin_family = sa_family_t(AF_INET)
+        addr.sin_port = frameworkServer.getServerPort().bigEndian
+        addr.sin_addr.s_addr = inet_addr("127.0.0.1")
+        let result = withUnsafePointer(to: &addr) {
+            $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
+                connect(fd, $0, socklen_t(MemoryLayout<sockaddr_in>.size))
+            }
+        }
+        guard result == 0 else {
+            close(fd)
+            throw LoopbackServerUnavailable(message: "raw client could not connect (errno \(errno))")
+        }
+        return fd
+    }
+
+    /// Polls until `condition` holds or `timeout` elapses. Returns whether it held.
+    private func waitUntil(timeout: TimeInterval = 5, _ condition: () -> Bool) -> Bool {
+        let deadline = Date().addingTimeInterval(timeout)
+        while Date() < deadline {
+            if condition() { return true }
+            Thread.sleep(forTimeInterval: 0.01)
+        }
+        return condition()
+    }
+
+    // MARK: - Connection lifecycle
+
+    /// stopServer() must cancel and clear connections that are still open. A
+    /// request/response test only hits this when a keep-alive connection
+    /// happens to be alive at teardown, which is timing-dependent; holding a
+    /// client open here makes that path run every time.
+    func testStopServer_WithOpenConnection_ClearsActiveConnections() throws {
+        try requireRunningServer()
+
+        let client = try openRawClient()
+        defer { close(client) }
+
+        XCTAssertTrue(
+            waitUntil { frameworkServer.activeConnectionCount() >= 1 },
+            "server never registered the open client connection"
+        )
+
+        frameworkServer.stopServer()
+
+        XCTAssertEqual(frameworkServer.activeConnectionCount(), 0)
+        XCTAssertFalse(frameworkServer.isRunning())
+    }
+
+    /// A client that resets mid-request (RST via zero-linger close) must be
+    /// dropped from the tracking set, whichever of the server's failed or
+    /// cancelled connection handlers observes it.
+    func testClientResetMidRequest_RemovesConnection() throws {
+        try requireRunningServer()
+
+        let client = try openRawClient()
+        XCTAssertTrue(
+            waitUntil { frameworkServer.activeConnectionCount() >= 1 },
+            "server never registered the client connection"
+        )
+
+        let partialRequest = Array("GET /partial".utf8)
+        _ = partialRequest.withUnsafeBytes { send(client, $0.baseAddress, $0.count, 0) }
+
+        var linger = linger(l_onoff: 1, l_linger: 0)
+        setsockopt(client, SOL_SOCKET, SO_LINGER, &linger, socklen_t(MemoryLayout<linger>.size))
+        close(client)
+
+        XCTAssertTrue(
+            waitUntil { frameworkServer.activeConnectionCount() == 0 },
+            "connection was not removed after the client reset"
+        )
+    }
+
     // MARK: - Status endpoint
 
     func testStatusEndpoint_ReturnsRunningJSON() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let port = frameworkServer.getServerPort()
         let sessionId = frameworkServer.getSessionId()
@@ -104,9 +235,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     // MARK: - File serving: success path
 
     func testFileRequest_ServesRealFileContent() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let content = "loopback test file content \(UUID().uuidString)"
         let servedURLString = try XCTUnwrap(
@@ -122,9 +251,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     }
 
     func testFileRequest_ContentLengthHeaderMatchesActualBytes() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let content = String(repeating: "x", count: 5000)
         let servedURLString = try XCTUnwrap(
@@ -143,9 +270,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     // MARK: - File serving: error paths
 
     func testFileRequest_UnknownFileId_Returns404() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let port = frameworkServer.getServerPort()
         let sessionId = frameworkServer.getSessionId()
@@ -157,9 +282,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     }
 
     func testInvalidRoute_Returns404() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let port = frameworkServer.getServerPort()
         let url = try XCTUnwrap(URL(string: "http://localhost:\(port)/not-a-real-route"))
@@ -170,9 +293,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     }
 
     func testNonGETMethod_Returns405() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let port = frameworkServer.getServerPort()
         let sessionId = frameworkServer.getSessionId()
@@ -186,9 +307,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     // MARK: - Physical file missing after being registered (not just unknown id)
 
     func testFileRequest_PhysicalFileDeletedAfterRegistration_Returns404() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let servedURLString = try XCTUnwrap(
             try serveTemporaryFile(content: "will be deleted from cache", fileName: "loopback-vanish.txt", mimeType: "text/plain")
@@ -218,9 +337,7 @@ final class FrameworkServerUtilsLoopbackTests: XCTestCase {
     // MARK: - removeServedFile
 
     func testRemoveServedFile_SubsequentRequestReturns404() async throws {
-        guard startServerAndWaitReady() else {
-            throw XCTSkip("Server failed to start in this environment — skipping loopback test")
-        }
+        try requireRunningServer()
 
         let servedURLString = try XCTUnwrap(
             try serveTemporaryFile(content: "to be removed", fileName: "loopback-remove.txt", mimeType: "text/plain")