Extract serial per-test coverage profiler substrate (#30)

Author: juntaki

Sources/AppleBuildAdapters/PerTestCoverageProfileAttempt.swift

@@ -0,0 +1,11 @@
+import MutationExecution
+
+/// The result of attempting an authoritative per-test coverage profile.
+///
+/// A fast profiler must either provide the complete map or decline so the
+/// serial reference profiler can produce it. Partial attribution is never a
+/// representable result.
+enum PerTestCoverageProfileAttempt: Sendable {
+    case complete(PerTestCoverageMap)
+    case unavailable(reason: String)
+}

Sources/AppleBuildAdapters/SwiftPackageMacOSAdapter.swift

@@ -552,6 +552,35 @@ extension SwiftPackageMacOSAdapter: TestSelecting {
         return selectedTests.count
     }
 
+    public func measurePerTestCoverage(
+        artifact: BuildArtifact,
+        in workspace: URL,
+        timeoutSeconds: Double
+    ) async -> PerTestCoverageMap? {
+        switch await measurePerTestCoverageFast(
+            artifact: artifact,
+            in: workspace,
+            timeoutSeconds: timeoutSeconds
+        ) {
+        case .complete(let map):
+            return map
+        case .unavailable:
+            return await measurePerTestCoverageSerial(
+                artifact: artifact,
+                in: workspace,
+                timeoutSeconds: timeoutSeconds
+            )
+        }
+    }
+
+    private func measurePerTestCoverageFast(
+        artifact: BuildArtifact,
+        in workspace: URL,
+        timeoutSeconds: Double
+    ) async -> PerTestCoverageProfileAttempt {
+        .unavailable(reason: "no fast per-test coverage backend is implemented yet")
+    }
+
     /// Runs every test `swift test list` reports, one at a time, with
     /// coverage enabled, against the artifact already built for the
     /// baseline — no separate coverage build step: `swift test
@@ -592,7 +621,7 @@ extension SwiftPackageMacOSAdapter: TestSelecting {
     ///   from `swift test list`, not from the artifact, and per-test
     ///   coverage needs its own coverage-instrumented run regardless of what
     ///   `artifact` was built with.
-    public func measurePerTestCoverage(
+    private func measurePerTestCoverageSerial(
         artifact: BuildArtifact,
         in workspace: URL,
         timeoutSeconds: Double

Sources/AppleBuildAdapters/XcodeBuildAdapter.swift

@@ -1216,6 +1216,35 @@ extension XcodeBuildAdapter: TestSelecting {
         )
     }
 
+    public func measurePerTestCoverage(
+        artifact: BuildArtifact,
+        in workspace: URL,
+        timeoutSeconds: Double
+    ) async -> PerTestCoverageMap? {
+        switch await measurePerTestCoverageFast(
+            artifact: artifact,
+            in: workspace,
+            timeoutSeconds: timeoutSeconds
+        ) {
+        case .complete(let map):
+            return map
+        case .unavailable:
+            return await measurePerTestCoverageSerial(
+                artifact: artifact,
+                in: workspace,
+                timeoutSeconds: timeoutSeconds
+            )
+        }
+    }
+
+    private func measurePerTestCoverageFast(
+        artifact: BuildArtifact,
+        in workspace: URL,
+        timeoutSeconds: Double
+    ) async -> PerTestCoverageProfileAttempt {
+        .unavailable(reason: "no fast per-test coverage backend is implemented yet")
+    }
+
     /// Runs every test the baseline bundle reports, one at a time, against
     /// the artifact already built for the baseline — no rebuild — with
     /// coverage enabled and its own scratch result bundle, and merges what
@@ -1257,7 +1286,7 @@ extension XcodeBuildAdapter: TestSelecting {
     ///   every individual test run, exactly the same "instrumented copy is
     ///   never what activation evidence is measured against" split
     ///   `readCoverage` makes.
-    public func measurePerTestCoverage(
+    private func measurePerTestCoverageSerial(
         artifact: BuildArtifact,
         in workspace: URL,
         timeoutSeconds: Double

Tests/MutantKitTests/Acceptance/PerTestProfilingFailClosedAcceptanceTests.swift

@@ -21,6 +21,23 @@ import Testing
     .enabled(if: Acceptance.isEnabled)
 )
 struct PerTestProfilingFailClosedAcceptanceTests {
+    @Test("The unavailable fast profiler falls back to the serial reference profiler")
+    func unavailableFastProfilerFallsBackToSerialReferenceProfiler() async throws {
+        let workspace = try Acceptance.stageFixture("SwiftPackageMacOS")
+        defer { try? FileManager.default.removeItem(at: workspace) }
+
+        let adapter = SwiftPackageMacOSAdapter(configuration: Configuration())
+        let artifact = try await adapter.buildBaseline(in: workspace)
+
+        let map = await adapter.measurePerTestCoverage(artifact: artifact, in: workspace, timeoutSeconds: 60)
+
+        let profile = try #require(map, "the serial reference profiler produced no attribution")
+        #expect(
+            profile.source == "swiftpm-codecov-per-test",
+            "the public profiler did not return the serial reference profiler's result"
+        )
+    }
+
     @Test("An unmeasurable test invalidates the whole per-test coverage map, not just its own entry")
     func unmeasurableTestProducesNoUsableMap() async throws {
         let workspace = try Acceptance.stageFixture("PerTestProfilingPartialFailure")

Tests/MutantKitTests/Acceptance/XcodePerTestProfilingFailClosedAcceptanceTests.swift

@@ -25,6 +25,35 @@ import Testing
     .enabled(if: Acceptance.simulatorEnabled)
 )
 struct XcodePerTestProfilingFailClosedAcceptanceTests {
+    @Test("The unavailable fast profiler falls back to the serial reference profiler")
+    func unavailableFastProfilerFallsBackToSerialReferenceProfiler() async throws {
+        let workspace = try Acceptance.stageFixture("XcodeProject")
+        defer { try? FileManager.default.removeItem(at: workspace) }
+
+        let destination = try Acceptance.iPhoneDestination()
+        let configuration = Configuration(
+            project: ProjectSettings(kind: .xcodeProject, scheme: "Checkout", destination: destination)
+        )
+        let adapter = XcodeBuildAdapter(
+            configuration: configuration,
+            kind: .xcodeProject,
+            projectFile: nil,
+            projectRoot: workspace
+        )
+
+        let artifact = try await adapter.buildBaseline(in: workspace)
+        let baseline = try await adapter.runBaseline(artifact, in: workspace, timeoutSeconds: 120)
+        #expect(baseline.status == .passed, "the Checkout baseline must produce the serial profiler's test bundle")
+        let profile = try #require(
+            await adapter.measurePerTestCoverage(artifact: artifact, in: workspace, timeoutSeconds: 120),
+            "the serial reference profiler produced no attribution"
+        )
+        #expect(
+            profile.source == "xcodebuild-xccov-per-test",
+            "the public profiler did not return the serial reference profiler's result"
+        )
+    }
+
     @Test("An unmeasurable test invalidates the whole per-test coverage map, not just its own entry")
     func unmeasurableTestProducesNoUsableMap() async throws {
         let workspace = try Acceptance.stageFixture("XcodeProject")