add coverage tests

Author: bkhouri

Sources/Commands/SwiftTestCommand.swift

@@ -240,7 +240,7 @@ package enum CoverageFormat: String, ExpressibleByArgument, CaseIterable, Compar
 
 extension CoverageFormat: Encodable {}
 
-enum CoveragePrintPathMode: String, ExpressibleByArgument, CaseIterable {
+package enum CoveragePrintPathMode: String, ExpressibleByArgument, CaseIterable {
     case json
     case text
 
@@ -1131,11 +1131,11 @@ extension SwiftTestCommand {
         }
     }
 
-    func printCodeCovPath(
+    package func getCodeCovOutputPaths(
         _ swiftCommandState: SwiftCommandState,
         formats: [CoverageFormat],
         printMode: CoveragePrintPathMode,
-    ) async throws {
+    ) async throws -> String {
         var coverageData = [CoverageFormat : AbsolutePath]()
         for format in formats {
             let config = try await self.getCodeCoverageConfiguration(swiftCommandState, format: format)
@@ -1165,7 +1165,20 @@ extension SwiftTestCommand {
                     data = try encoder.encode(coverageOutput)
                 }
         }
-        print(String(decoding: data, as: UTF8.self))
+        return String(decoding: data, as: UTF8.self)
+    }
+
+    package func printCodeCovPath(
+        _ swiftCommandState: SwiftCommandState,
+        formats: [CoverageFormat],
+        printMode: CoveragePrintPathMode,
+    ) async throws {
+        let output = try await self.getCodeCovOutputPaths(
+            swiftCommandState,
+            formats: formats,
+            printMode: printMode,
+        )
+        print(output)
     }
 }
 

Tests/CommandsTests/CoverageTests.swift

@@ -13,13 +13,15 @@
 import Foundation
 import RegexBuilder
 import Commands
+import CoreCommands
 import _InternalTestSupport
 import enum PackageModel.BuildConfiguration
 import func Basics.resolveSymlinks
 import struct Basics.AbsolutePath
 import struct SPMBuildCore.BuildSystemProvider
 import var Basics.localFileSystem
 import Testing
+import class TSCBasic.BufferedOutputByteStream
 
 @Suite(
     .serializedIfOnWindows,
@@ -284,6 +286,7 @@ struct CoverageTests {
             "configuration",
             "coverage.html.report.args.txt",
         ]
+
         @Test(
             .tags(
                 .Feature.Command.Test,
@@ -296,8 +299,6 @@ struct CoverageTests {
             buildData: BuildData,
             isResponseFileOutputAbsolutePath: Bool,
         ) async throws {
-            // let buildSystem = BuildSystemProvider.Kind.native
-            // let configuration = BuildConfiguration.debug
             let buildSystem = buildData.buildSystem
             let configuration = buildData.config
             try await withKnownIssue{
@@ -337,6 +338,42 @@ struct CoverageTests {
             }
         }
 
+        @Test(
+            .tags(
+                .Feature.Command.Test,
+            ),
+            arguments: getBuildData(for: SupportedBuildSystemOnAllPlatforms),
+        )
+        func existenceOfResponseFileWithNotOutputDirectorySpecifiedUsedTheDefaultLocation(
+            buildData: BuildData,
+        ) async throws {
+            let buildSystem = buildData.buildSystem
+            let configuration = buildData.config
+            // Verify the output directory argument specified in the response file override the default location.
+            try await fixture(name: "Coverage/Simple") { fixturePath in
+                let responseFilePath = fixturePath.appending(components: responseFilePathComponents)
+                let responseFileContent = "--tab-size=10"
+
+                try localFileSystem.createDirectory(responseFilePath.parentDirectory, recursive: true)
+                try localFileSystem.writeFileContents(responseFilePath, string: responseFileContent)
+
+                let (stdout, _) = try await executeSwiftTest(
+                    fixturePath,
+                    configuration: configuration,
+                    extraArgs: [
+                        "--show-coverage-path",
+                        "--coverage-format",
+                        "html",
+                    ],
+                    buildSystem: buildSystem,
+                )
+                let actualOutput = stdout.trimmingCharacters(in: .whitespacesAndNewlines)
+
+                #expect(actualOutput.contains(fixturePath.pathString))
+            }
+        }
+
+
         @Test(
             arguments: getBuildData(for: SupportedBuildSystemOnAllPlatforms),
         )
@@ -346,27 +383,6 @@ struct CoverageTests {
             // Verify the arguments specified in the response file are used.
             try await fixture(name: "Coverage/Simple") { fixturePath in
                 let responseFilePath = fixturePath.appending(components: responseFilePathComponents)
-                let expectedRegex = Regex {
-                    "debug: "
-                    OneOrMore {
-                        .word
-
-                    }
-                    "llvm-cov show"
-                    ZeroOrMore {
-                        .any
-                    }
-                    OneOrMore(.whitespace)
-                    "@"
-                    ZeroOrMore { // >> /tmp and /var can be symlinks, so we take this into account
-                        .any
-                    }
-                    "\(responseFilePath)"
-                    OneOrMore(.whitespace)
-                    ZeroOrMore {
-                        .any
-                    }
-                }.anchorsMatchLineEndings()
 
                 try localFileSystem.writeFileContents(responseFilePath, string: "")
                 expectFileExists(at: responseFilePath)
@@ -384,30 +400,137 @@ struct CoverageTests {
                     $0.contains("llvm-cov show") && $0.contains(responseFileArgument) //$0.contains("@\(responseFilePath)")
                 }
                 #expect(contains.count >= 1)
-                // #expect(
-                //     stderr.contains(expectedRegex),
-                //     """
-                //     expectedRegex: \(expectedRegex)
-                //     responseFilePath: \(responseFilePath)
-
-                //     stderr\n------\n\(stderr)
-                //     """
-                // )
             }
         }
     }
 
     @Suite
-    struct showCoveragePathTests {
-        @Test
-        func printPathModeTests() async throws {
-            Issue.record("""
-            Test needs to be implemented. Need to implnente cross matix of:
-             - single/multiple formats
-             - print in text/json format
-             - specifying the same format type multiple times
-             - response file [overrides | does not override] output directory
-            """)
+    struct ShowCoveragePathTests {
+        let commonTestArgs = [
+            "--show-codecov-path"
+        ]
+        struct ShowCoveragePathTestData {
+            let formats: [CoverageFormat]
+            let printMode: CoveragePrintPathMode
+            let expected: String
+        }
+        @Test(
+            arguments: getBuildData(for: SupportedBuildSystemOnAllPlatforms), [
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.html],
+                    printMode: CoveragePrintPathMode.text,
+                    expected: "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html",
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.json],
+                    printMode: CoveragePrintPathMode.text,
+                    expected: "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json",
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.html, .json],
+                    printMode: CoveragePrintPathMode.text,
+                    expected: """
+                        Html: $(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html
+                        Json: $(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json
+                        """,
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.json, .html],
+                    printMode: CoveragePrintPathMode.text,
+                    expected: """
+                        Html: $(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html
+                        Json: $(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json
+                        """,
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.json, .html, .json],
+                    printMode: CoveragePrintPathMode.text,
+                    expected: """
+                        Html: $(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html
+                        Json: $(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json
+                        """,
+                ),
+
+
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.html],
+                    printMode: CoveragePrintPathMode.json,
+                    expected: """
+                        {
+                          "html" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html"
+                        }
+                        """,
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.json],
+                    printMode: CoveragePrintPathMode.json,
+                    expected: """
+                        {
+                          "json" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json"
+                        }
+                        """,
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.html, .json],
+                    printMode: CoveragePrintPathMode.json,
+                    expected: """
+                        {
+                          "html" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html",
+                          "json" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json"
+                        }
+                        """,
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.json, .html],
+                    printMode: CoveragePrintPathMode.json,
+                    expected: """
+                        {
+                          "html" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html",
+                          "json" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json"
+                        }
+                        """,
+                ),
+                ShowCoveragePathTestData(
+                    formats: [CoverageFormat.json, .html, .json],
+                    printMode: CoveragePrintPathMode.json,
+                    expected: """
+                        {
+                          "html" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple-html",
+                          "json" : "$(DEFAULT_BUILD_OUTPUT)/codecov/Simple.json"
+                        }
+                        """,
+                ),
+
+            ]
+        )
+        func specifiedFormatsFormatInTextModeOnlyDisplaysThePath(
+            buildData: BuildData,
+            testData: ShowCoveragePathTestData,
+        ) async throws {
+            let buildSystem = buildData.buildSystem
+            let configuration = buildData.config
+            try await fixture(name: "Coverage/Simple") { fixturePath in 
+                let defaultBuildOUtput = try await executeSwiftBuild(
+                    fixturePath,
+                    configuration: configuration,
+                    extraArgs: ["--show-bin-path"],
+
+                    buildSystem: buildSystem,
+                ).stdout.trimmingCharacters(in: .whitespacesAndNewlines)
+                let updatedExpected = testData.expected.replacing("$(DEFAULT_BUILD_OUTPUT)", with: defaultBuildOUtput)
+
+                let actual = try await executeSwiftTest(
+                    fixturePath,
+                    configuration: configuration,
+                    extraArgs: self.commonTestArgs + [
+                        "--show-codecov-path-mode",
+                        testData.printMode.rawValue,
+                    ] + testData.formats.flatMap({ ["--coverage-format", $0.rawValue]}),
+                    buildSystem: buildSystem,
+                ).stdout.trimmingCharacters(in: .whitespacesAndNewlines)
+
+                #expect(actual == updatedExpected)
+            }
         }
     }