fix(fossid-webapp): Ignore duplicate rule creation

A change in FossID 24.2.1 is that the API server returns an error when
the client tries to create an ignore rule when an identical rule already
exists. The situation can arise because of global ignore rules: defined by
an operator, they are automatically assigned to a newly created scan.
Therefore, when listing the rules of a previous delta scan, these global
rules are also present.
The previous commit didn't resolve the issue fully therefore this commit
fixes the issue by simply ignoring duplicate rule creation.

Signed-off-by: Nicolas Nobelis <[email protected]>

Author: nnobelis

plugins/scanners/fossid/src/main/kotlin/events/CloneRepositoryHandler.kt

@@ -151,17 +151,22 @@ class CloneRepositoryHandler(val config: FossIdConfig, val service: FossIdServic
 
         val allRules = excludesRules + legacyRules
         allRules.forEach {
-            service.createIgnoreRule(
+            val response = service.createIgnoreRule(
                 config.user.value,
                 config.apiKey.value,
                 scanCode,
                 it.type,
                 it.value,
                 RuleScope.SCAN
-            ).checkResponse("create ignore rules", false)
+            )
+            // It could be that global rules are automatically added to a scan. Therefore, a failure in creation
+            // because of duplication should be ignored.
+            if (response.error != "Rule already exists") {
+                response.checkResponse("create ignore rules", false)
 
-            logger.info {
-                "Ignore rule of type '${it.type}' and value '${it.value}' has been created for the new scan."
+                logger.info {
+                    "Ignore rule of type '${it.type}' and value '${it.value}' has been created for the new scan."
+                }
             }
         }
 

plugins/scanners/fossid/src/test/kotlin/FossIdTest.kt

@@ -55,6 +55,8 @@ import org.ossreviewtoolkit.clients.fossid.downloadFromGit
 import org.ossreviewtoolkit.clients.fossid.extractArchives
 import org.ossreviewtoolkit.clients.fossid.listIgnoreRules
 import org.ossreviewtoolkit.clients.fossid.listScansForProject
+import org.ossreviewtoolkit.clients.fossid.model.rules.IgnoreRule
+import org.ossreviewtoolkit.clients.fossid.model.rules.RuleType
 import org.ossreviewtoolkit.clients.fossid.model.status.DownloadStatus
 import org.ossreviewtoolkit.clients.fossid.model.status.ScanStatus
 import org.ossreviewtoolkit.clients.fossid.removeUploadedContent
@@ -700,6 +702,60 @@ class FossIdTest : WordSpec({
             }
         }
 
+        "should not fail when trying to create a legacy rule if it already exist" {
+            val projectCode = PROJECT
+            val originCode = "originalScanCode"
+            val scanCode = scanCode(PROJECT, FossId.DeltaTag.DELTA)
+            val config = createConfig()
+            val vcsInfo = createVcsInfo()
+            val scan = createScan(vcsInfo.url, vcsInfo.revision, originCode)
+
+            val existingRule = IgnoreRule(
+                SCAN_ID,
+                RuleType.DIRECTORY,
+                "*.git",
+                SCAN_ID,
+                "Global rule for .git directories"
+            )
+
+            val service = FossIdRestService.create(config.serverUrl)
+                .expectProjectRequest(projectCode)
+                .expectListScans(projectCode, listOf(scan))
+                .expectCheckScanStatus(originCode, ScanStatus.FINISHED)
+                .expectCheckScanStatus(scanCode, ScanStatus.NOT_STARTED, ScanStatus.FINISHED)
+                .expectCreateScan(projectCode, scanCode, vcsInfo)
+                .expectDownload(scanCode)
+                .expectListIgnoreRules(originCode, listOf(existingRule))
+                .expectCreateIgnoreRule(scanCode, existingRule.type, existingRule.value, error = true)
+                .mockFiles(scanCode)
+            coEvery { service.runScan(any()) } returns EntityResponseBody(status = 1)
+
+            val fossId = createFossId(config)
+
+            fossId.scan(
+                createPackage(createIdentifier(index = 1), vcsInfo),
+                mapOf(FossId.PROJECT_REVISION_LABEL to "master")
+            )
+
+            val comment = createOrtScanComment(vcsInfo.url, vcsInfo.revision, "master").asJsonString()
+            coVerify {
+                service.createScan(USER, API_KEY, projectCode, scanCode, vcsInfo.url, vcsInfo.revision, comment)
+                service.downloadFromGit(USER, API_KEY, scanCode)
+                service.checkDownloadStatus(USER, API_KEY, scanCode)
+                service.runScan(
+                    USER,
+                    API_KEY,
+                    scanCode,
+                    mapOf(
+                        *FossId.deltaScanRunParameters(originCode),
+                        "auto_identification_detect_declaration" to "0",
+                        "auto_identification_detect_copyright" to "0",
+                        "sensitivity" to "10"
+                    )
+                )
+            }
+        }
+
         "create a delta scan for an existing scan with a legacy comment" {
             val projectCode = PROJECT
             val originCode = "originalScanCode"

plugins/scanners/fossid/src/test/kotlin/TestUtils.kt

@@ -544,6 +544,26 @@ internal fun FossIdServiceWithVersion.expectListIgnoreRules(
     return this
 }
 
+/**
+ * Prepare this service mock to return the list of [rules] for the given [scanCode].
+ */
+internal fun FossIdServiceWithVersion.expectCreateIgnoreRule(
+    scanCode: String,
+    type: RuleType,
+    value: String,
+    scope: RuleScope = RuleScope.SCAN,
+    error: Boolean = false
+): FossIdServiceWithVersion {
+    if (error) {
+        coEvery { createIgnoreRule(USER, API_KEY, scanCode, type, value, scope) } returns
+            EntityResponseBody("create ignore rules", error = "Rule already exists")
+    } else {
+        coEvery { createIgnoreRule(USER, API_KEY, scanCode, type, value, scope) } returns EntityResponseBody()
+    }
+
+    return this
+}
+
 /**
  * Prepare this service mock to expect a request to create an 'ignore rule' for the given [scanCode], [ruleType],
  * [value] and [scope].