clean: Move ToolRepository logic to trait to simplify testing

To avoid repeating the logic of getting a single tool
and listing tools (with the risk of having unfaithful tests),
I moved the implementation of `listSupportedTools` and `getTool` to the
`ToolRepository` trait and added a `protected def allTools`
to make `ToolRepositoryMock` behave exactly as the `RemoteToolRepository`
when getting or listing tools

Author: lolgab

cli/src/main/scala/com/codacy/analysis/cli/CLIError.scala

@@ -19,8 +19,6 @@ object CLIError {
       case AnalyserError.NoActiveToolInConfiguration              => CLIError.NoActiveToolInConfiguration
       case AnalyserError.NoToolsFoundForFiles                     => CLIError.NoToolsFoundForFiles
       case AnalyserError.FailedToFetchTools(errorMessage)         => CLIError.CouldNotGetTools(errorMessage)
-      case AnalyserError.FailedToFindTool(toolUuid) =>
-        CLIError.CouldNotGetTools(s"Failure to get tool with UUID: $toolUuid")
       case AnalyserError.FailedToListPatterns(toolUuid, errorMessage) =>
         CLIError.CouldNotGetTools(s"Failure getting patterns for tool with UUID $toolUuid. Error: $errorMessage")
     }

cli/src/test/scala/com/codacy/analysis/cli/ToolSelectorSpec.scala

@@ -37,14 +37,13 @@ class ToolSelectorSpec extends Specification with NoLanguageFeatures {
         standalone = false,
         hasUIConfiguration = true)
 
-    override def listSupportedTools(): Either[AnalyserError, Seq[ToolSpec]] =
-      Right(
-        Seq(
-          getToolSpec("34225275-f79e-4b85-8126-c7512c987c0d", "PyLint", Set(Python)),
-          getToolSpec("c6273c22-5248-11e5-885d-feff819cdc9f", "Brakeman", Set(Languages.Ruby)),
-          getToolSpec("724f98da-f616-4e37-9606-f16919137a1e", "Rubocop", Set(Languages.Ruby)),
-          getToolSpec("38794ba2-94d8-4178-ab99-1f5c1d12760c", "BundlerAudit", Set(Languages.Ruby)),
-          getToolSpec("cf05f3aa-fd23-4586-8cce-5368917ec3e5", "ESLint", Set(Languages.Javascript))))
+    override val allTools = Right(
+      Seq(
+        getToolSpec("34225275-f79e-4b85-8126-c7512c987c0d", "PyLint", Set(Python)),
+        getToolSpec("c6273c22-5248-11e5-885d-feff819cdc9f", "Brakeman", Set(Languages.Ruby)),
+        getToolSpec("724f98da-f616-4e37-9606-f16919137a1e", "Rubocop", Set(Languages.Ruby)),
+        getToolSpec("38794ba2-94d8-4178-ab99-1f5c1d12760c", "BundlerAudit", Set(Languages.Ruby)),
+        getToolSpec("cf05f3aa-fd23-4586-8cce-5368917ec3e5", "ESLint", Set(Languages.Javascript))))
 
     override def listPatterns(tool: ToolSpec): Either[AnalyserError, Seq[PatternSpec]] = Right(Seq.empty)
 

core/src/main/scala/com/codacy/analysis/core/tools/ToolRepository.scala

@@ -4,10 +4,22 @@ import com.codacy.analysis.core.model.{AnalyserError, DuplicationToolSpec, Metri
 
 trait ToolRepository {
 
-  def listSupportedTools(): Either[AnalyserError, Seq[ToolSpec]]
+  protected def allTools: Either[AnalyserError, Seq[ToolSpec]]
+
+  def listSupportedTools(): Either[AnalyserError, Seq[ToolSpec]] =
+    allTools.map(_.filterNot(_.standalone))
+
+  def getTool(queryString: String): Either[AnalyserError, ToolSpec] =
+    allTools.flatMap { toolsSpecs =>
+      toolsSpecs.find(
+        tool => tool.shortName.equalsIgnoreCase(queryString) || tool.uuid.equalsIgnoreCase(queryString)) match {
+        case None                          => Left(AnalyserError.NonExistingToolInput(queryString))
+        case Some(tool) if tool.standalone => Left(AnalyserError.StandaloneToolInput(queryString))
+        case Some(tool)                    => Right(tool)
+      }
+    }
   def listDuplicationTools(): Either[AnalyserError, Seq[DuplicationToolSpec]]
   def listMetricsTools(): Either[AnalyserError, Seq[MetricsToolSpec]]
-  def getTool(queryString: String): Either[AnalyserError, ToolSpec]
   def listPatterns(tool: ToolSpec): Either[AnalyserError, Seq[PatternSpec]]
 
 }

core/src/test/scala/com.codacy.analysis.core/ToolRepositoryMock.scala

@@ -19,7 +19,7 @@ object ToolRepositoryMock extends ToolRepository {
   private val brakemanId = "c6273c22-5248-11e5-885d-feff819cdc9f"
   private val scalastyleId = "21586cd3-3eaa-4454-878e-ac0211a833c2"
 
-  override def listSupportedTools(): Either[AnalyserError, Seq[ToolSpec]] =
+  override val allTools: Either[AnalyserError, Seq[ToolSpec]] =
     Right(
       Seq(
         ToolSpec(
@@ -103,9 +103,6 @@ object ToolRepositoryMock extends ToolRepository {
           standalone = false,
           hasUIConfiguration = true)))
 
-  override def getTool(uuid: String): Either[AnalyserError, ToolSpec] =
-    listSupportedTools().flatMap(_.find(_.uuid == uuid).toRight(AnalyserError.FailedToFindTool(uuid)))
-
   private def getSimplePattern(patternId: String): PatternSpec =
     PatternSpec(patternId, "Info", "ErrorProne", None, patternId, None, None, enabled = true, None, Seq(), Set())
 

core/src/test/scala/com.codacy.analysis.core/tools/ToolRepositoryStub.scala

@@ -5,10 +5,9 @@ import com.codacy.analysis.core.model.{AnalyserError, PatternSpec, ToolSpec}
 
 class ToolRepositoryStub extends ToolRepository {
 
-  def listSupportedTools(): Either[AnalyserError, Seq[ToolSpec]] = ???
+  def allTools: Either[AnalyserError, Seq[ToolSpec]] = ???
   def listDuplicationTools(): Either[AnalyserError, Seq[model.DuplicationToolSpec]] = ???
   def listMetricsTools(): Either[AnalyserError, Seq[model.MetricsToolSpec]] = ???
-  def getTool(uuid: String): Either[AnalyserError, ToolSpec] = ???
   def listPatterns(tool: ToolSpec): Either[AnalyserError, Seq[PatternSpec]] = ???
 
 }

model/src/main/scala/com/codacy/analysis/core/model/AnalyserError.scala

@@ -39,10 +39,6 @@ object AnalyserError {
     override val message: String = s"Failed to list tools with error: $errorMessage"
   }
 
-  final case class FailedToFindTool(toolUuid: String) extends AnalyserError {
-    override val message: String = s"Failed to find tool with UUID: $toolUuid"
-  }
-
   final case class FailedToListPatterns(toolUuid: String, errorMessage: String) extends AnalyserError {
 
     override val message: String =

toolRepository-remote/src/main/scala/com/codacy/toolRepository/remote/ToolRepositoryRemote.scala

@@ -43,7 +43,7 @@ class ToolRepositoryRemote(toolsClient: ToolsClient,
     extends ToolRepository {
   private val logger: Logger = getLogger
 
-  private lazy val allTools: Either[AnalyserError, Seq[ToolSpec]] = {
+  override lazy val allTools: Either[AnalyserError, Seq[ToolSpec]] = {
     val source = PaginatedApiSourceFactory { cursor =>
       toolsClient.listTools(cursor).value.map {
         case Right(ListToolsResponse.OK(ToolListResponse(data, None | Some(PaginationInfo(None, _, _))))) =>
@@ -110,19 +110,6 @@ class ToolRepositoryRemote(toolsClient: ToolsClient,
     }
   }
 
-  override def listSupportedTools(): Either[AnalyserError, Seq[ToolSpec]] =
-    allTools.map(_.filterNot(_.standalone))
-
-  override def getTool(queryString: String): Either[AnalyserError, ToolSpec] =
-    allTools.flatMap { toolsSpecs =>
-      toolsSpecs.find(
-        tool => tool.shortName.equalsIgnoreCase(queryString) || tool.uuid.equalsIgnoreCase(queryString)) match {
-        case None                          => Left(AnalyserError.FailedToFindTool(queryString))
-        case Some(tool) if tool.standalone => Left(AnalyserError.StandaloneToolInput(queryString))
-        case Some(tool)                    => Right(tool)
-      }
-    }
-
   private def patternsFromApi(tool: ToolSpec): Either[AnalyserError, Seq[PatternSpec]] = {
     val source = PaginatedApiSourceFactory { cursor =>
       toolsClient.listPatterns(tool.uuid, cursor = cursor).value.map {