JUnit report sensor

src/main/scala/com/mwz/sonar/scala/ScalaPlugin.scala

@@ -122,9 +122,9 @@ final class ScalaPlugin extends Plugin {
       classOf[scoverage.ScoverageMetrics],
       classOf[scoverage.ScoverageReportParser],
       classOf[scoverage.ScoverageSensor],
-      // Unit tests.
-      classOf[junit.JUnitSensor],
+      // JUnit.
       classOf[junit.JUnitReportParser],
+      classOf[junit.JUnitSensor]
     )
   }
 }

src/main/scala/com/mwz/sonar/scala/junit/JUnitReportParser.scala

@@ -30,6 +30,11 @@ import scala.collection.JavaConverters._
 import scala.xml.{Elem, XML}
 
 trait JUnitReportParserAPI {
+
+  /**
+   * Parse JUnit report files from the given directory
+   * and return a map from input files to the parsed reports.
+   */
   def parse(tests: List[Path], directories: List[File]): Map[InputFile, JUnitReport]
 }
 
@@ -43,16 +48,15 @@ final class JUnitReportParser(fileSystem: FileSystem) extends JUnitReportParserA
 
     // Parse report files.
     val unitTestReports: List[JUnitReport] = parseReportFiles(reports)
-
-    log.debug("Unit test reports:")
-    log.debug(unitTestReports.mkString(", "))
+    if (unitTestReports.nonEmpty)
+      log.debug(s"JUnit test reports:\n${unitTestReports.mkString(", ")}")
 
     // Convert package names into files.
     resolveFiles(tests, unitTestReports)
   }
 
   /**
-   * Get report files - xml files starting with "TEST-"
+   * Get report files - xml files starting with "TEST-".
    */
   private[junit] def reportFiles(directories: List[File]): List[File] = {
     val reportFiles: List[File] = directories.filter(_.isDirectory).flatMap { dir =>
@@ -93,24 +97,25 @@ final class JUnitReportParser(fileSystem: FileSystem) extends JUnitReportParserA
   ): Map[InputFile, JUnitReport] = {
     reports
       .groupBy(_.name)
-      .map {
+      .flatMap {
         case (name, reports) =>
-          val filePath: String = name.replace(".", "/")
+          val path: String = name.replace(".", "/")
+          val files: List[Path] = tests.map(_.resolve(s"$path.scala"))
           val predicates: List[FilePredicate] =
-            tests.map { path =>
-              fileSystem.predicates.hasPath(path.resolve(s"$filePath.scala").toString)
-            }
-          val files: Iterable[InputFile] =
+            files.map(f => fileSystem.predicates.hasPath(f.toString))
+
+          val inputFiles: Iterable[InputFile] =
             fileSystem
               .inputFiles(
                 fileSystem.predicates.or(predicates.asJava)
               )
               .asScala
 
-          // Collect the first file here.
-          files.headOption.flatMap(file => reports.headOption.map((file, _)))
+          if (files.isEmpty)
+            log.error(s"The following files were not found: ${files.mkString(", ")}")
+
+          // Collect all of the input files.
+          inputFiles.flatMap(file => reports.headOption.map((file, _)))
       }
-      .collect { case Some(e) => e } // unNone
-      .toMap
   }
 }

src/main/scala/com/mwz/sonar/scala/junit/JUnitSensor.scala

@@ -28,15 +28,17 @@ import org.sonar.api.batch.fs.{FileSystem, InputFile}
 import org.sonar.api.batch.sensor.{Sensor, SensorContext, SensorDescriptor}
 import org.sonar.api.config.Configuration
 import org.sonar.api.measures.CoreMetrics
-import org.sonar.api.scan.filesystem.PathResolver
 
-import scala.util.Try
+import scala.collection.JavaConverters._
 
+/**
+ * Scala JUnit sensor.
+ * Parses JUnit XML reports and saves test metrics.
+ */
 final class JUnitSensor(
   untTestsReportParser: JUnitReportParserAPI,
   config: Configuration,
-  fs: FileSystem,
-  pathResolver: PathResolver
+  fs: FileSystem // TODO: Is the injected fileSystem different from context.fileSystem?
 ) extends Sensor {
   import JUnitSensor._ // scalastyle:ignore org.scalastyle.scalariform.ImportGroupingChecker
 
@@ -46,39 +48,52 @@ final class JUnitSensor(
     descriptor
       .name(SensorName)
       .onlyOnLanguage(Scala.LanguageKey)
+      .onlyOnFileType(InputFile.Type.TEST)
+    // TODO: Add a flag to disable the sensor.
   }
 
   override def execute(context: SensorContext): Unit = {
     log.info("Initializing the Scala JUnit sensor.")
 
+    // Get the test paths.
     val tests: List[Path] = fromConfig(config, TestsPropertyKey, DefaultTests)
+    log.debug(s"The source prefixes are: ${tests.mkString("[", ",", "]")}.")
+
+    // Get the junit report paths.
     val reports: List[Path] = fromConfig(config, ReportsPropertyKey, DefaultReportPaths)
+    log.debug(s"The JUnit report paths are: ${reports.mkString("[", ",", "]")}.")
 
-    val inputFiles = context.fileSystem
-      .inputFiles(
-        context.fileSystem.predicates.and(
-          context.fileSystem.predicates.hasLanguage(Scala.LanguageKey),
-          context.fileSystem.predicates.hasType(InputFile.Type.TEST)
+    // Get test input files
+    val inputFiles: Iterable[InputFile] =
+      context.fileSystem
+        .inputFiles(
+          context.fileSystem.predicates.and(
+            context.fileSystem.predicates.hasLanguage(Scala.LanguageKey),
+            context.fileSystem.predicates.hasType(InputFile.Type.TEST)
+          )
         )
-      )
+        .asScala
 
-    log.debug("Input test files:")
-    inputFiles.forEach(f => log.debug(f.toString))
+    if (inputFiles.nonEmpty)
+      log.debug(s"Input test files: \n${inputFiles.mkString(", ")}")
+    else
+      log.warn(s"No test files found for module ${context.module.key}.")
 
-    val directories: List[File] =
-      reports.flatMap(path => Try(pathResolver.relativeFile(fs.baseDir, path.toString)).toOption)
-    // TODO: Is the injected fileSystem different from context.fileSystem?
+    // Resolve test directories.
+    val testDirectories: List[File] = resolve(fs, tests)
+    if (testDirectories.isEmpty)
+      log.error(s"The following test directories were not found: ${reports.mkString(", ")}.")
 
-    if (directories.isEmpty)
-      log.warn(s"JUnit test report path(s) not found for ${reports.mkString(", ")}.")
-    else {
-      val parsedReports: Map[InputFile, JUnitReport] = untTestsReportParser.parse(tests, directories)
-      log.debug("Parsed reports:")
-      log.debug(parsedReports.mkString(", "))
+    // Resolve JUnit report directories.
+    val reportDirectories: List[File] = resolve(fs, reports)
+    if (reportDirectories.isEmpty)
+      log.error(s"The following JUnit test report path(s) were not found : ${reports.mkString(", ")}.")
 
-      // Save test metrics for each file.
-      save(context, parsedReports)
-    }
+    // Parse the reports.
+    val parsedReports: Map[InputFile, JUnitReport] = untTestsReportParser.parse(tests, reportDirectories)
+
+    // Save test metrics for each file.
+    save(context, parsedReports)
   }
 
   /**
@@ -102,6 +117,11 @@ final class JUnitSensor(
           (report.time * 1000).longValue
         )
     }
+
+    if (reports.nonEmpty)
+      log.debug(s"Parsed reports:\n${reports.mkString(", ")}")
+    else
+      log.info("No test metrics were saved by this sensor.")
   }
 }
 

src/main/scala/com/mwz/sonar/scala/util/Log.scala

@@ -32,7 +32,7 @@ object Log {
   def apply[T](clazz: Class[T], module: String): Log = Log(clazz, Some(module))
   def apply[T](clazz: Class[T], module: Option[String] = None): Log = {
     val log: Logger = Loggers.get(clazz)
-    val prefix: String = "sonar-scala" + module.map("-" + _).getOrElse("")
+    val prefix: String = "sonar-scala" + module.fold("")("-" + _)
     new Log {
       override def debug(s: String): Unit = log.debug(s"[$prefix] $s")
       override def info(s: String): Unit = log.info(s"[$prefix] $s")

src/main/scala/com/mwz/sonar/scala/util/util.scala

@@ -19,6 +19,7 @@
 package com.mwz.sonar.scala
 package util
 
+import java.io.File
 import java.nio.file.{Path, Paths}
 import java.util.Optional
 
@@ -27,7 +28,8 @@ import org.sonar.api.batch.measure.Metric
 import org.sonar.api.batch.sensor.SensorContext
 import org.sonar.api.config.Configuration
 
-import scala.language.implicitConversions
+import scala.language.{higherKinds, implicitConversions}
+import scala.util.Try
 
 /**
  *  Scala.Option <-> Java.Optional conversions.
@@ -94,6 +96,14 @@ object PathUtils {
     val currentWorkdirAbsolutePath = PathUtils.cwd
     currentWorkdirAbsolutePath.relativize(moduleAbsolutePath)
   }
+
+  /**
+   * Resolve a list of paths relative to the given file system.
+   */
+  def resolve(fs: FileSystem, toResolve: List[Path]): List[File] =
+    toResolve.flatMap { path =>
+      Try(fs.resolvePath(path.toString)).toOption
+    }
 }
 
 object MetricUtils {

src/test/scala/com/mwz/sonar/scala/ScalaPluginSpec.scala

@@ -60,4 +60,9 @@ class ScalaPluginSpec extends FlatSpec with Matchers {
     assert(context.getExtensions.contains(classOf[scoverage.ScoverageReportParser]))
     assert(context.getExtensions.contains(classOf[scoverage.ScoverageSensor]))
   }
+
+  it should "provide junit sensor" in {
+    assert(context.getExtensions.contains(classOf[junit.JUnitReportParser]))
+    assert(context.getExtensions.contains(classOf[junit.JUnitSensor]))
+  }
 }