fix(fossid-webapp): Always create a new scan when delta scans are disabled

The current logic always tries to reuse the existing scans on the same
branch if delta scans logic is disabled. This is incorrect as the code in
the repository for this branch may have changed (rolling revision).
This commit enforces that a new scan is always created when delta scans are
disabled.

Signed-off-by: Nicolas Nobelis <nicolas.nobelis@bosch.com>

Author: nnobelis

plugins/scanners/fossid/src/main/kotlin/FossId.kt

@@ -304,16 +304,7 @@ class FossId internal constructor(
                 val result = if (config.deltaScans) {
                     checkAndCreateDeltaScan(handler, scans, url, revision, projectCode, repositoryName, context)
                 } else {
-                    checkAndCreateScan(
-                        handler,
-                        scans,
-                        url,
-                        revision,
-                        projectCode,
-                        repositoryName,
-                        nestedProvenance,
-                        context
-                    )
+                    checkAndCreateScan(handler, url, revision, projectCode, repositoryName, context)
                 }
 
                 if (config.waitForResult && provenance is RepositoryProvenance) {
@@ -501,12 +492,10 @@ class FossId internal constructor(
     @Suppress("LongParameterList")
     private suspend fun checkAndCreateScan(
         handler: EventHandler,
-        scans: List<Scan>,
         url: String,
         revision: String,
         projectCode: String,
         projectName: String,
-        nestedProvenance: NestedProvenance?,
         context: ScanContext
     ): FossIdResult {
         val projectRevision = context.labels[PROJECT_REVISION_LABEL]
@@ -517,41 +506,18 @@ class FossId internal constructor(
             logger.info { "Project revision is '$projectRevision'." }
         }
 
-        val existingScan = scans.recentScansForRepository(
-            url,
-            revision = revision,
-            projectRevision = projectRevision
-        ).findLatestPendingOrFinishedScan()
-
-        val result = if (existingScan == null) {
-            logger.info { "No scan found for $url and revision $revision. Creating scan..." }
+        logger.info { "Creating scan for $url and revision $revision..." }
 
-            val scanCode = namingProvider.createScanCode(repositoryName = projectName, branch = revision)
-            val newUrl = handler.transformURL(url)
-            val scanId = createScan(handler, projectCode, scanCode, newUrl, revision, projectRevision.orEmpty())
+        val scanCode = namingProvider.createScanCode(repositoryName = projectName, branch = revision)
+        val newUrl = handler.transformURL(url)
+        val scanId = createScan(handler, projectCode, scanCode, newUrl, revision, projectRevision.orEmpty())
 
-            val issues = mutableListOf<Issue>()
-            handler.afterScanCreation(scanCode, null, issues, context)
-
-            if (config.waitForResult) checkScan(handler, scanCode)
-
-            FossIdResult(scanCode, scanId, issues)
-        } else {
-            logger.info { "Scan '${existingScan.code}' found for $url and revision $revision." }
-
-            val existingScanCode = requireNotNull(existingScan.code) {
-                "The code for an existing scan must not be null."
-            }
-
-            // Create a specific handler for the existing scan.
-            val handlerForExistingScan = EventHandler.getHandler(existingScan, config, nestedProvenance, service)
-
-            if (config.waitForResult) checkScan(handlerForExistingScan, existingScan.code.orEmpty())
+        val issues = mutableListOf<Issue>()
+        handler.afterScanCreation(scanCode, null, issues, context)
 
-            FossIdResult(existingScanCode, existingScan.id.toString())
-        }
+        if (config.waitForResult) checkScan(handler, scanCode)
 
-        return result
+        return FossIdResult(scanCode, scanId, issues)
     }
 
     /**

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

@@ -66,22 +66,6 @@ interface EventHandler {
 
                 CloneRepositoryHandler(config, service)
             }
-
-        /**
-         * Return an [EventHandler] based on the given [config], [nestedProvenance] and [service]. The handler is
-         * tailored for the given [existingScan].
-         */
-        fun getHandler(
-            existingScan: Scan,
-            config: FossIdConfig,
-            nestedProvenance: NestedProvenance?,
-            service: FossIdServiceWithVersion
-        ): EventHandler {
-            // Create a specific handler for the existing scan, based on its configuration, not to the current scanner
-            // configuration.
-            val configForExistingScan = config.copy(isArchiveMode = existingScan.gitRepoUrl == null)
-            return getHandler(configForExistingScan, nestedProvenance, service)
-        }
     }
 
     /**

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

@@ -757,15 +757,13 @@ internal fun FossIdServiceWithVersion.expectUploadArchiveWorkflow(
     apply {
         expectProjectRequest(projectCode)
         expectListScans(projectCode, existingScans)
-        // TODO: This should be done only if deltaScans is true, but currently the tests with delta scans disabled still
-        //       rely on existing scans.
-        existingScans.forEach {
-            it.code?.also { existingScanCode ->
-                expectCheckScanStatus(existingScanCode, ScanStatus.FINISHED)
+        if (deltaScans) {
+            existingScans.forEach {
+                it.code?.also { existingScanCode ->
+                    expectCheckScanStatus(existingScanCode, ScanStatus.FINISHED)
+                }
             }
-        }
 
-        if (deltaScans) {
             expectCheckScanStatus(scanCode, ScanStatus.NOT_STARTED, ScanStatus.FINISHED)
         } else {
             expectCheckScanStatus(scanCode, ScanStatus.FINISHED)
@@ -821,13 +819,12 @@ internal fun FossIdServiceWithVersion.expectCloneRepositoryWorkflow(
     apply {
         expectProjectRequest(projectCode)
         expectListScans(projectCode, existingScans)
-        // TODO: This should be done only if deltaScans is true, but currently the tests with delta scans disabled still
-        //       rely on existing scans.
-
-        val resolvedExistingScanCode = existingScanCode ?: existingScans.takeIf { it.isNotEmpty() }?.last()?.code
-        if (resolvedExistingScanCode != null) {
-            expectCheckScanStatus(resolvedExistingScanCode, ScanStatus.FINISHED)
-            expectListIgnoreRules(resolvedExistingScanCode, existingIgnoreRules)
+        if (deltaScans) {
+            val resolvedExistingScanCode = existingScanCode ?: existingScans.takeIf { it.isNotEmpty() }?.last()?.code
+            if (resolvedExistingScanCode != null) {
+                expectCheckScanStatus(resolvedExistingScanCode, ScanStatus.FINISHED)
+                expectListIgnoreRules(resolvedExistingScanCode, existingIgnoreRules)
+            }
         }
 
         val statuses = checkScanStatuses ?: if (deltaScans) {