Add missing categories TS-682 (#149)

* add missing categories

* fix fmt

* publish artifact

* refactor

---------

Co-authored-by: Rafael Cortês <[email protected]>

Author: codacy-vrhpires

.circleci/config.yml

@@ -67,7 +67,6 @@ jobs:
             - "*"
 
 workflows:
-  version: 2
   build-and-deploy:
     jobs:
       - codacy/checkout_and_version:
@@ -104,10 +103,6 @@ workflows:
           name: publish_artifacts
           files: artifacts/codacy-plugins-test-linux
           path: bin/codacy-plugins-test
-          filters:
-            branches:
-              only:
-                - master
           context: CodacyAWS
           requires:
             - compress_and_package_artifacts

src/main/scala/codacy/plugins/test/JsonTests.scala

@@ -2,7 +2,7 @@ package codacy.plugins.test
 
 import codacy.utils.CollectionHelper
 import com.codacy.plugins.api.PatternDescription
-import com.codacy.plugins.api.results.Pattern
+import com.codacy.plugins.api.results.{Category, Pattern, Tool}
 import com.codacy.plugins.results.traits.DockerToolDocumentation
 import com.codacy.plugins.runners.IDocker
 import com.codacy.plugins.utils.BinaryDockerHelper
@@ -39,70 +39,90 @@ object JsonTests extends ITest {
       }
     }
 
-    (dockerToolDocumentation.toolSpecification, dockerToolDocumentation.patternDescriptions) match {
-      case (Some(tool), Some(descriptions)) =>
-        val diffResult = new CollectionHelper[Pattern.Specification, PatternDescription, String](tool.patterns.toSeq,
-                                                                                                 descriptions.toSeq)({
-          pattern =>
-            val parameters = pattern.parameters.map(_.name.value).toSeq.sorted
-            generateUniquePatternSignature(pattern.patternId.value, parameters)
-        }, { description =>
-          val parameters = description.parameters.getOrElse(Seq.empty).map(_.name.value).toSeq.sorted
-          generateUniquePatternSignature(description.patternId.value, parameters)
-        }).fastDiff
-
-        val duplicateDescriptions = descriptions.groupBy(_.patternId).filter { case (_, v) => v.size > 1 }
-        if (duplicateDescriptions.nonEmpty) {
-          error(s"""
+    val onlyAllowedCategories =
+      dockerToolDocumentation.toolSpecification.map(validatePatternCategory).getOrElse(true)
+
+    val noMismatchBetweenPatternsAndDescription =
+      (dockerToolDocumentation.toolSpecification, dockerToolDocumentation.patternDescriptions) match {
+        case (Some(tool), Some(descriptions)) =>
+          val diffResult = new CollectionHelper[Pattern.Specification, PatternDescription, String](tool.patterns.toSeq,
+                                                                                                   descriptions.toSeq)({
+            pattern =>
+              val parameters = pattern.parameters.map(_.name.value).toSeq.sorted
+              generateUniquePatternSignature(pattern.patternId.value, parameters)
+          }, { description =>
+            val parameters = description.parameters.getOrElse(Seq.empty).map(_.name.value).toSeq.sorted
+            generateUniquePatternSignature(description.patternId.value, parameters)
+          }).fastDiff
+
+          val duplicateDescriptions = descriptions.groupBy(_.patternId).filter { case (_, v) => v.size > 1 }
+          if (duplicateDescriptions.nonEmpty) {
+            error(s"""
                |Some patterns were duplicated in /docs/description/description.json
                |
                |  * ${duplicateDescriptions.map { case (patternId, _) => patternId }.mkString(",")}
               """.stripMargin)
-        }
+          }
 
-        if (diffResult.newObjects.nonEmpty) {
-          error(s"""
+          if (diffResult.newObjects.nonEmpty) {
+            error(s"""
                |Some patterns were only found in /docs/patterns.json
                |Confirm that all the patterns and parameters present in /docs/patterns.json are also present in /docs/description/description.json
                |
                |  * ${diffResult.newObjects.map(_.patternId).mkString(",")}
               """.stripMargin)
-        }
+          }
 
-        if (diffResult.deletedObjects.nonEmpty) {
-          error(s"""
+          if (diffResult.deletedObjects.nonEmpty) {
+            error(s"""
                |Some patterns were only found in /docs/description/description.json
                |Confirm that all the patterns and parameters present in /docs/description/description.json are also present in /docs/patterns.json
                |
                |  * ${diffResult.deletedObjects.map(_.patternId).mkString(",")}
               """.stripMargin)
-        }
+          }
 
-        val titlesAboveLimit = descriptions.filter(_.title.length > 255)
-        if (titlesAboveLimit.nonEmpty) {
-          error(s"""
+          val titlesAboveLimit = descriptions.filter(_.title.length > 255)
+          if (titlesAboveLimit.nonEmpty) {
+            error(s"""
                |Some titles are too big in /docs/description/description.json
                |The max size of a title is 255 characters
                |
                | * ${titlesAboveLimit.map(_.patternId).mkString(", ")}
               """.stripMargin)
-        }
+          }
 
-        val descriptionsAboveLimit = descriptions.filter(_.description.getOrElse("").length > 500)
-        if (descriptionsAboveLimit.nonEmpty) {
-          error(s"""
+          val descriptionsAboveLimit = descriptions.filter(_.description.getOrElse("").length > 500)
+          if (descriptionsAboveLimit.nonEmpty) {
+            error(s"""
                |Some descriptions are too big in /docs/description/description.json
                |The max size of a description is 500 characters
                |
                | * ${descriptionsAboveLimit.map(_.patternId).mkString(", ")}
               """.stripMargin)
-        }
+          }
 
-        ignoreDescriptions ||
-        (diffResult.newObjects.isEmpty && diffResult.deletedObjects.isEmpty)
+          ignoreDescriptions ||
+          (diffResult.newObjects.isEmpty && diffResult.deletedObjects.isEmpty)
 
-      case _ => ignoreDescriptions
-    }
+        case _ => ignoreDescriptions
+      }
+
+    onlyAllowedCategories && noMismatchBetweenPatternsAndDescription
+  }
+
+  // TS-682: Validate disabled categories aren't used
+  private def validatePatternCategory(toolSpec: Tool.Specification): Boolean = {
+    toolSpec.patterns.forall(pattern => {
+      val isAllowed = Category.allowedCategories.contains(pattern.category)
+      if (!isAllowed) {
+        error(s"""
+            | Disabled category "${pattern.category}" used by pattern "${pattern.patternId}".
+            | Allowed categories are: ${Category.allowedCategories.mkString(",")}.
+            """.stripMargin)
+      }
+      isAllowed
+    })
   }
 
   private def readDockerToolDocumentation(dockerImage: DockerImage) = {

src/main/scala/com/codacy/plugins/api/results/Category.scala

@@ -0,0 +1,9 @@
+package com.codacy.plugins.api.results
+
+object Category {
+
+  // TS-682: Return only categories that are enabled in the production database
+  val allowedCategories = Pattern.Category.values
+    .filterNot(_ == Pattern.Category.Duplication)
+
+}