ci: unit test adjustments

NathanWalker · NathanWalker · commit 91e51cd7cacc · 2026-06-26T12:37:26.000-07:00
[skip ci]
diff --git a/.github/workflows/npm_release.yml b/.github/workflows/npm_release.yml
@@ -241,9 +241,24 @@ jobs:
           # Simulator app crashes land in the host's DiagnosticReports.
           cp -R ~/Library/Logs/DiagnosticReports/. "$DIAG/DiagnosticReports/" 2>/dev/null || true
           cp -R ~/Library/Logs/CoreSimulator/. "$DIAG/CoreSimulator/" 2>/dev/null || true
-          # Unified log from the booted simulator: the app's console output, so
-          # the last spec before a hang is visible even when nothing was POSTed.
-          xcrun simctl spawn booted log collect --output "$DIAG/simulator.logarchive" 2>/dev/null || true
+          # Unified log = the app's console output (so the last spec before a hang
+          # is visible even when nothing was POSTed). `log collect` needs a booted
+          # device; don't rely on the `booted` alias (the prior collect failed
+          # because the sim wasn't booted at that moment). Resolve a concrete UDID
+          # — prefer one already booted from the test run, else the test device,
+          # booting it so the persisted log store can be collected.
+          UDID="$(xcrun simctl list devices booted | grep -oE '[0-9A-Fa-f-]{36}' | head -1)"
+          if [ -z "$UDID" ]; then
+            UDID="$(xcrun simctl list devices 'iPhone 15 Pro Max' | grep -oE '[0-9A-Fa-f-]{36}' | head -1)"
+            [ -n "$UDID" ] && xcrun simctl boot "$UDID" 2>/dev/null || true
+            [ -n "$UDID" ] && xcrun simctl bootstatus "$UDID" 2>/dev/null || true
+          fi
+          if [ -n "$UDID" ]; then
+            echo "Collecting unified log from simulator $UDID"
+            xcrun simctl spawn "$UDID" log collect --output "$DIAG/simulator.logarchive" 2>/dev/null || true
+          else
+            echo "No simulator UDID resolved; skipping logarchive collection."
+          fi
           echo "Collected diagnostics:"; ls -laR "$DIAG" 2>/dev/null || true
       - name: Upload test diagnostics (on failure)
         if: ${{ failure() }}
diff --git a/TestRunner/app/Infrastructure/Jasmine/jasmine-2.0.1/boot.js b/TestRunner/app/Infrastructure/Jasmine/jasmine-2.0.1/boot.js
@@ -133,6 +133,32 @@ var TerminalReporter = require('../jasmine-reporters/terminal_reporter').Termina
   }));
   jasmine.getEnv().addReporter(new JUnitXmlReporter());
 
+  // Progress beacon: fire-and-forget GET of each suite/spec name to the XCTest
+  // host's /progress endpoint. When the suite hangs (no JUnit report is ever
+  // POSTed), this lets the Swift harness name the spec that was running when the
+  // JS thread stalled. Async via NSURLSession so it never blocks the JS thread;
+  // best-effort — any error is swallowed.
+  (function installProgressBeacon() {
+    try {
+      var reportUrl = NSProcessInfo.processInfo.environment.objectForKey("REPORT_BASEURL");
+      if (!reportUrl) { return; }
+      var origin = new URL(String(reportUrl)).origin;
+      var beacon = function (name) {
+        try {
+          var url = origin + "/progress?spec=" + encodeURIComponent(name || "");
+          var req = NSMutableURLRequest.requestWithURL(NSURL.URLWithString(url));
+          req.HTTPMethod = "GET";
+          req.timeoutInterval = 2.0;
+          NSURLSession.sharedSession.dataTaskWithRequestCompletionHandler(req, function () {}).resume();
+        } catch (e) { /* best-effort */ }
+      };
+      jasmine.getEnv().addReporter({
+        suiteStarted: function (r) { beacon("[suite] " + (r && r.fullName ? r.fullName : "")); },
+        specStarted: function (r) { beacon(r && r.fullName ? r.fullName : ""); }
+      });
+    } catch (e) { /* best-effort */ }
+  }());
+
   env.specFilter = function(spec) {
     return true;
   };
diff --git a/TestRunner/app/tests/HttpEsmLoaderTests.js b/TestRunner/app/tests/HttpEsmLoaderTests.js
@@ -167,7 +167,10 @@ describe("HTTP ESM Loader", function() {
             // Prefer the local XCTest-hosted HTTP server (when available) to avoid ATS restrictions
             // and make this test deterministic.
             var origin = getHostOrigin();
-            var spec = origin ? (origin + "/esm/timeout.mjs?delayMs=6500") : "https://192.0.2.1:5173/timeout-test.js";
+            // Prefer the local XCTest server's delayed endpoint (deterministic, hermetic).
+            // The fallback is a closed local port (fast connection-refused), never a live
+            // external/TEST-NET host whose connect timeout would stall the JS thread on CI.
+            var spec = origin ? (origin + "/esm/timeout.mjs?delayMs=6500") : "http://127.0.0.1:59999/timeout-test.js";
 
             import(spec).then(function(module) {
                 fail("Should not have succeeded for unreachable server");
diff --git a/TestRunner/app/tests/RemoteModuleSecurityTests.js b/TestRunner/app/tests/RemoteModuleSecurityTests.js
@@ -18,16 +18,28 @@
 // - With allowlist: Only URLs matching a prefix in remoteModuleAllowlist are allowed
 
 describe("Remote Module Security", function() {
-    
+
+    // Hermetic by design: never touch live external hosts (esm.sh, TEST-NET
+    // 192.0.2.1, example.com). HTTP module fetches are SYNCHRONOUS on the JS
+    // thread (HMRSupport.mm: NSURLConnection sendSynchronousRequest), so a slow
+    // or transitively-fanning remote import (e.g. esm.sh pulling a graph of
+    // sub-modules) blocks the event loop and, accumulated, runs the whole suite
+    // past its timeout on CI -> false "hang". A closed local port fails fast
+    // with a connection-refused *network* error, which is exactly what every
+    // debug-mode spec below asserts: the security gate lets the request through
+    // (so it's NOT a security error) and the fetch then fails on the network.
+    var DEAD_HTTP = "http://127.0.0.1:59999";
+    var DEAD_HTTPS = "https://127.0.0.1:59999";
+
     describe("Debug Mode Behavior", function() {
         // In debug mode (test environment), all remote modules should be allowed
         // regardless of security configuration
         
         it("should allow HTTP module imports in debug mode", function(done) {
-            // This test uses a known unreachable IP to trigger the HTTP loading path
-            // In debug mode, the security check passes and we get a network error
-            // (not a security error)
-            import("http://192.0.2.1:5173/test-module.js").then(function(module) {
+            // Uses a closed local port to trigger the HTTP loading path and fail
+            // fast. In debug mode the security check passes and we get a network
+            // error (connection refused), NOT a security error.
+            import(DEAD_HTTP + "/test-module.js").then(function(module) {
                 // If we somehow succeed, that's fine too
                 expect(module).toBeDefined();
                 done();
@@ -42,8 +54,8 @@ describe("Remote Module Security", function() {
         });
         
         it("should allow HTTPS module imports in debug mode", function(done) {
-            // Test HTTPS URL - should be allowed in debug mode
-            import("https://192.0.2.1:5173/test-module.js").then(function(module) {
+            // Test HTTPS URL - should be allowed in debug mode (closed local port -> fast network error)
+            import(DEAD_HTTPS + "/test-module.js").then(function(module) {
                 expect(module).toBeDefined();
                 done();
             }).catch(function(error) {
@@ -96,9 +108,9 @@ describe("Remote Module Security", function() {
         // code paths for HTTP loading are exercised correctly
         
         it("should handle allowlisted URL prefixes", function(done) {
-            // esm.sh is in our test allowlist
-            // In debug mode this is allowed anyway, but tests the path
-            import("https://esm.sh/test-module").then(function(module) {
+            // In debug mode the allowlist is not enforced; this just exercises the
+            // remote-load path and confirms we get a network (not security) error.
+            import(DEAD_HTTPS + "/test-module").then(function(module) {
                 expect(module).toBeDefined();
                 done();
             }).catch(function(error) {
@@ -111,7 +123,7 @@ describe("Remote Module Security", function() {
         
         it("should handle non-allowlisted URLs in debug mode", function(done) {
             // This URL is NOT in the allowlist, but debug mode allows it anyway
-            import("https://not-in-allowlist.example.com/module.js").then(function(module) {
+            import(DEAD_HTTPS + "/not-allowlisted/module.js").then(function(module) {
                 expect(module).toBeDefined();
                 done();
             }).catch(function(error) {
@@ -132,7 +144,7 @@ describe("Remote Module Security", function() {
         it("should allow importing from allowlisted static HTTP URLs", function(done) {
             // This test verifies the ResolveModuleCallback security check path
             // is exercised for static imports
-            const testUrl = "https://esm.sh/@test/module";
+            const testUrl = DEAD_HTTPS + "/@test/module";
             
             import(testUrl).then(function(module) {
                 expect(module).toBeDefined();
@@ -152,7 +164,7 @@ describe("Remote Module Security", function() {
         // handling code doesn't crash
         
         it("should provide clear errors for failed HTTP imports", function(done) {
-            import("http://invalid-url-test:9999/module.js").then(function(module) {
+            import(DEAD_HTTP + "/module.js").then(function(module) {
                 done();
             }).catch(function(error) {
                 expect(error).toBeDefined();
@@ -188,7 +200,7 @@ describe("Remote Module Security", function() {
         
         it("should handle URLs with special characters", function(done) {
             // URLs with encoded characters should be handled properly
-            import("https://example.com/module%20with%20spaces.js").then(function(module) {
+            import(DEAD_HTTPS + "/module%20with%20spaces.js").then(function(module) {
                 done();
             }).catch(function(error) {
                 // Error handling should not crash
@@ -198,7 +210,7 @@ describe("Remote Module Security", function() {
         });
         
         it("should handle URLs with query parameters", function(done) {
-            import("https://esm.sh/lodash?target=es2020").then(function(module) {
+            import(DEAD_HTTPS + "/lodash?target=es2020").then(function(module) {
                 done();
             }).catch(function(error) {
                 // Query params should be preserved in URL handling
@@ -208,7 +220,7 @@ describe("Remote Module Security", function() {
         });
         
         it("should handle URLs with fragments", function(done) {
-            import("https://esm.sh/module#section").then(function(module) {
+            import(DEAD_HTTPS + "/module#section").then(function(module) {
                 done();
             }).catch(function(error) {
                 expect(error).toBeDefined();
diff --git a/TestRunnerTests/TestRunnerTests.swift b/TestRunnerTests/TestRunnerTests.swift
@@ -6,6 +6,12 @@ class TestRunnerTests: XCTestCase {
     private var server: HTTPServer!
     private var runtimeUnitTestsExpectation: XCTestExpectation!
 
+    // Most recent spec reported by the in-app Jasmine progress beacon (see the
+    // /progress handler below). When the suite hangs and never POSTs results,
+    // this names the spec that was running when the JS thread stalled.
+    private let progressLock = NSLock()
+    private var lastSpecSeen = "(no spec reported yet)"
+
     override func setUp() {
         continueAfterFailure = false
 
@@ -25,6 +31,24 @@ class TestRunnerTests: XCTestCase {
             let path = (environ["PATH_INFO"] as? String) ?? "/"
             let query = (environ["QUERY_STRING"] as? String) ?? ""
 
+            // Progress beacon from the in-app Jasmine reporter (fire-and-forget):
+            // records the spec currently running so a hang/timeout can report
+            // where the JS suite stalled, even though no JUnit report is POSTed.
+            if method == "GET" && path == "/progress" {
+                if let specParam = query
+                    .split(separator: "&")
+                    .first(where: { $0.hasPrefix("spec=") }) {
+                    let raw = String(specParam.dropFirst("spec=".count))
+                    let decoded = raw.removingPercentEncoding ?? raw
+                    self.progressLock.lock()
+                    self.lastSpecSeen = decoded
+                    self.progressLock.unlock()
+                }
+                startResponse("204 No Content", [])
+                sendBody(Data())
+                return
+            }
+
             // Serve tiny ESM modules for runtime HTTP loader tests.
             if method == "GET" {
                 if path == "/esm/query.mjs" || path == "/ns/m/query.mjs" {
@@ -202,7 +226,10 @@ class TestRunnerTests: XCTestCase {
             }
             return
         case .timedOut:
-            XCTFail("Ran past \(Int(jasmineTestsTimeout))s with the \"Jasmine tests\" expectation unfulfilled while the app was STILL RUNNING -> the JS suite HUNG (deadlock or never-settled async); it did not crash. Check the 'test-diagnostics' artifact (simulator.logarchive) for the last spec that logged before the stall.")
+            progressLock.lock()
+            let lastSpec = lastSpecSeen
+            progressLock.unlock()
+            XCTFail("Ran past \(Int(jasmineTestsTimeout))s with the \"Jasmine tests\" expectation unfulfilled while the app was STILL RUNNING -> the JS suite HUNG (deadlock or never-settled async); it did not crash. Last spec reported by the in-app beacon: \"\(lastSpec)\". Also see the 'test-diagnostics' artifact (simulator.logarchive).")
         default:
             XCTFail("Unexpected XCTWaiter result: \(result.rawValue)")
         }
