Add tests for utils

Author: machadoit

circle.yml

@@ -1,7 +1,7 @@
 machine:
   java:
     version: oraclejdk8
-    
+
 test:
   override:
     - sbt clean coverage test

src/main/scala/codacy/dockerApi/utils/CommandRunner.scala

@@ -19,15 +19,18 @@ object CommandRunner {
 
     val pio = new ProcessIO(_.close(), readStream(stdout), readStream(stderr))
 
-    val process = Process(cmd, dir).run(pio)
-    val result = Try(process.exitValue())
+    Try(Process(cmd, dir).run(pio)) match {
+      case Success(process) =>
+        Try(process.exitValue()) match {
+          case Success(exitValue) =>
+            Right(CommandResult(exitValue, stdout, stderr))
 
-    result match {
-      case Success(exitValue) =>
-        Right(CommandResult(exitValue, stdout, stderr))
+          case Failure(e) =>
+            process.destroy()
+            Left(e)
+        }
 
       case Failure(e) =>
-        process.destroy()
         Left(e)
     }
   }

src/main/scala/codacy/dockerApi/utils/FileHelper.scala

@@ -28,7 +28,7 @@ object FileHelper {
 
   def stripPath(filename: String, prefix: String): String = {
 
-    val FilenameRegex = s""".*$prefix/(.*)""".r
+    val FilenameRegex = s""".*$prefix/*(.*)""".r
 
     filename match {
       case FilenameRegex(res) => res;

src/main/scala/codacy/dockerApi/utils/ToolHelper.scala

@@ -4,38 +4,29 @@ import codacy.dockerApi._
 
 object ToolHelper {
 
-  def getPatternsToLint(conf: Option[Seq[PatternDef]])(implicit spec: Spec): Seq[PatternDef] = {
-    conf.fold(getDefaultConfFromSpec(spec)) {
+  def getPatternsToLint(conf: Option[Seq[PatternDef]])(implicit spec: Spec): Option[Seq[PatternDef]] = {
+    conf.map {
       configuration =>
         configuration.map(pattern => getMissingParametersFromSpec(pattern))
     }
   }
 
-  private def convertToParametersDefFromSpec(parametersSpec: Option[Set[ParameterSpec]]): Option[Set[ParameterDef]] = {
-    parametersSpec.map(params => params.map(param => ParameterDef(param.name, param.default)))
-  }
-
-  private def getDefaultConfFromSpec(spec: Spec): Seq[PatternDef] = {
-    spec.patterns.toSeq.map(pattern => PatternDef(pattern.patternId, convertToParametersDefFromSpec(pattern.parameters)))
-  }
-
-
   private def buildParameterDefFromSpec(parameterSpec: ParameterSpec): ParameterDef = {
     ParameterDef(parameterSpec.name, parameterSpec.default)
   }
 
-  private def getParametersByPatternId(patternId: PatternId)(implicit spec: Spec): Set[ParameterDef] = {
+  private def getParametersByPatternId(patternId: PatternId)(implicit spec: Spec): Option[Set[ParameterDef]] = {
     val specPattern = spec.patterns.find(_.patternId == patternId)
 
     specPattern.flatMap {
       patternSpec =>
         patternSpec.parameters.map(params => params.map(buildParameterDefFromSpec))
-    }.getOrElse(Set())
+    }
   }
 
   private def getMissingParametersFromSpec(pattern: PatternDef)(implicit spec: Spec): PatternDef = {
-    val params = pattern.parameters.getOrElse(getParametersByPatternId(pattern.patternId))
-    PatternDef(pattern.patternId, Some(params))
+    val params = pattern.parameters.orElse(getParametersByPatternId(pattern.patternId))
+    PatternDef(pattern.patternId, params)
   }
 
 }

src/test/scala/codacy/dockerApi/utils/CommandRunnerTest.scala

@@ -0,0 +1,33 @@
+package codacy.dockerApi.utils
+
+import org.scalatest._
+import org.scalatest.EitherValues._
+
+import scala.collection.mutable.ArrayBuffer
+
+class CommandRunnerTest extends FlatSpec with Matchers {
+
+  val genericCMD = Seq("echo", "foo")
+  val invalidCMD = Seq("rm", "nofile.ext")
+  val errorCMD = Seq("rmzzz", "nofile.ext")
+
+  "CommandRunner" should "simpleEchoExec" in {
+    val result: Either[Throwable, CommandResult] = CommandRunner.exec(genericCMD)
+
+    result.right.value.stdout should be(ArrayBuffer("foo"))
+    result.right.value.exitCode should be(0)
+  }
+
+  "CommandRunner" should "handleInvalidExec" in {
+    val result: Either[Throwable, CommandResult] = CommandRunner.exec(invalidCMD)
+
+    result.right.value.stdout should be(ArrayBuffer())
+    result.right.value.exitCode should be(1)
+  }
+
+  "CommandRunner" should "handleErrorExec" in {
+    val result: Either[Throwable, CommandResult] = CommandRunner.exec(errorCMD)
+
+    result should be('left)
+  }
+}

src/test/scala/codacy/dockerApi/utils/FileHelperTest.scala

@@ -0,0 +1,34 @@
+package codacy.dockerApi.utils
+
+import org.scalatest._
+
+class FileHelperTest extends FlatSpec with Matchers {
+
+  "FileHelper" should "stripPath from String" in {
+    val pathString: String = "a/b/c/filename.ext"
+    val pathStringPrefix: String = "a/b"
+
+    val pathString2: String = "/a/b/filename.ext"
+    val pathStringPrefix2: String = "/a/b/"
+
+    val result: String = FileHelper.stripPath(pathString, pathStringPrefix)
+    result should be("c/filename.ext")
+
+    val result2: String = FileHelper.stripPath(pathString2, pathStringPrefix2)
+    result2 should be("filename.ext")
+  }
+
+  "FileHelper" should "stripPath from Path" in {
+    val path: java.nio.file.Path = java.nio.file.Paths.get("a/b/c/filename.ext")
+    val pathPrefix: java.nio.file.Path = java.nio.file.Paths.get("a/b")
+
+    val path2: java.nio.file.Path = java.nio.file.Paths.get("/a/b/filename.ext")
+    val pathPrefix2: java.nio.file.Path = java.nio.file.Paths.get("/a/b/")
+
+    val result: String = FileHelper.stripPath(path, pathPrefix)
+    result should be("c/filename.ext")
+
+    val result2: String = FileHelper.stripPath(path2, pathPrefix2)
+    result2 should be("filename.ext")
+  }
+}

src/test/scala/codacy/dockerApi/utils/ToolHelperTest.scala

@@ -0,0 +1,68 @@
+package codacy.dockerApi.utils
+
+import codacy.dockerApi._
+import org.scalatest._
+import play.api.libs.json.{JsNumber, JsString}
+
+class ToolHelperTest extends FlatSpec with Matchers {
+
+  val paramSpec1 = ParameterSpec(ParameterName("param1"), JsNumber(2))
+  val paramSpec2 = ParameterSpec(ParameterName("param2"), JsString("value2"))
+  val patternSpec1 = PatternSpec(PatternId("id1"), Some(Set(paramSpec1, paramSpec2)))
+  val patternSpec2 = PatternSpec(PatternId("id2"), None)
+  val patternsSpec = Set(patternSpec1, patternSpec2)
+
+  val paramDef1 = ParameterDef(ParameterName("param1"), JsNumber(33))
+  val paramDef2 = ParameterDef(ParameterName("param2"), JsString("value33"))
+  val patternDef1 = PatternDef(PatternId("id1"), Some(Set(paramDef1, paramDef2)))
+  val patternDef2 = PatternDef(PatternId("id2"), None)
+
+  val patternDef1NoParam = PatternDef(PatternId("id1"), None)
+  val patternDef2NoParam = PatternDef(PatternId("id2"), None)
+
+  val genericSpec = codacy.dockerApi.Spec(ToolName("tool1"), patternsSpec)
+  val genericConf: Option[Seq[PatternDef]] = Some(Seq(patternDef1, patternDef2))
+  val genericConfNoParam: Option[Seq[PatternDef]] = Some(Seq(patternDef1NoParam, patternDef2NoParam))
+
+  "ToolHelper" should "getPatternsFromConf" in {
+    val spec = genericSpec
+    val conf = genericConf
+
+    val result = ToolHelper.getPatternsToLint(conf)(spec)
+
+    result should equal(conf)
+  }
+
+  "ToolHelper" should "getPatternsNoneIfNoConf" in {
+    val spec = genericSpec
+    val conf = None
+
+    val result = ToolHelper.getPatternsToLint(conf)(spec)
+
+    result should equal(None)
+  }
+
+  "ToolHelper" should "getPatternsEmptyIfEmptyConf" in {
+    val spec = genericSpec
+    val conf: Option[Seq[PatternDef]] = Some(Seq())
+
+    val result = ToolHelper.getPatternsToLint(conf)(spec)
+
+    result should equal(Some(Seq()))
+  }
+
+  "ToolHelper" should "getParametersFromSpec" in {
+    val spec = genericSpec
+    val conf = genericConfNoParam
+
+    val expectedParamDef1 = ParameterDef(ParameterName("param1"), JsNumber(2))
+    val expectedParamDef2 = ParameterDef(ParameterName("param2"), JsString("value2"))
+    val expectedPatternDef1 = PatternDef(PatternId("id1"), Some(Set(expectedParamDef1, expectedParamDef2)))
+    val expectedPatternDef2 = PatternDef(PatternId("id2"), None)
+    val expectedResult = Some(Seq(expectedPatternDef1, expectedPatternDef2))
+
+    val result = ToolHelper.getPatternsToLint(conf)(spec)
+
+    result should equal(expectedResult)
+  }
+}