feat(reporter): Resolve Reporter issues and remove fallback resolution

Apply merged repository/global resolutions to Reporter issues, persist
resolved items, and compute unresolved issue logging from resolved
mappings.

Remove the Reporter fallback that resolved all issues and vulnerabilities
when the Evaluator did not run. Each worker now resolves its own items,
making this catch-all unnecessary.

Resolves #4365.

Signed-off-by: Jyrki Keisala <jyrki.keisala@doubleopen.org>

Author: Etsija

workers/reporter/src/main/kotlin/ReporterRunner.kt

@@ -49,7 +49,6 @@ import org.eclipse.apoapsis.ortserver.workers.common.context.WorkerContext
 import org.eclipse.apoapsis.ortserver.workers.common.mapOptions
 import org.eclipse.apoapsis.ortserver.workers.common.readConfigFileValueWithDefault
 import org.eclipse.apoapsis.ortserver.workers.common.readConfigFileWithDefault
-import org.eclipse.apoapsis.ortserver.workers.common.resolveResolutionsWithMappings
 import org.eclipse.apoapsis.ortserver.workers.common.resolvedConfigurationContext
 
 import org.ossreviewtoolkit.model.OrtResult
@@ -123,7 +122,6 @@ class ReporterRunner(
         )
 
         var resolvedOrtResult = ortResult
-        var resolvedItems: ResolvedItemsResult? = null
 
         if (evaluatorConfig == null) {
             // Resolve package configurations if not already done by the evaluator.
@@ -156,14 +154,6 @@ class ReporterRunner(
             val resolutionProvider = DefaultResolutionProvider(resolutionsFromOrtResult.merge(resolutionsFromFile))
 
             resolvedOrtResult = resolvedOrtResult.setResolutions(resolutionProvider)
-
-            // Compute resolved items mappings when evaluator didn't run.
-            resolvedItems = resolveResolutionsWithMappings(
-                issues = resolvedOrtResult.getIssues().values.flatten(),
-                ruleViolations = emptyList(), // No evaluator = no rule violations
-                vulnerabilities = resolvedOrtResult.getVulnerabilities().values.flatten(),
-                resolutionProvider = resolutionProvider
-            )
         }
 
         val howToFixTextProviderScript = context.configManager.readConfigFileWithDefault(
@@ -189,12 +179,12 @@ class ReporterRunner(
             howToFixTextProvider
         )
 
-        // Only return the package configurations and resolved items if they were not already resolved by
-        // the evaluator.
+        // Only return the package configurations if not already resolved by the evaluator.
+        // Resolved items are always null here; each worker resolves its own items.
         return ReporterRunnerResult(
             reportNames,
             resolvedOrtResult.resolvedConfiguration.packageConfigurations.takeIf { evaluatorConfig == null },
-            resolvedItems,
+            null,
             issues = issues
         )
     }

workers/reporter/src/main/kotlin/ReporterWorker.kt

@@ -33,12 +33,14 @@ import org.eclipse.apoapsis.ortserver.workers.common.RunResult
 import org.eclipse.apoapsis.ortserver.workers.common.context.WorkerContextFactory
 import org.eclipse.apoapsis.ortserver.workers.common.env.EnvironmentService
 import org.eclipse.apoapsis.ortserver.workers.common.loadGlobalResolutions
+import org.eclipse.apoapsis.ortserver.workers.common.resolveResolutionsWithMappings
 import org.eclipse.apoapsis.ortserver.workers.common.validateForProcessing
 
 import org.jetbrains.exposed.v1.jdbc.Database
 
 import org.ossreviewtoolkit.model.Repository
 import org.ossreviewtoolkit.model.Severity
+import org.ossreviewtoolkit.model.utils.DefaultResolutionProvider
 import org.ossreviewtoolkit.utils.ort.ORT_VERSION
 
 import org.slf4j.LoggerFactory
@@ -116,6 +118,20 @@ internal class ReporterWorker(
                 reports = reports
             )
 
+            val allIssues = reporterRunnerResult.issues
+            val reporterIssuesAsOrt = allIssues.map { it.mapToOrt() }
+
+            val resolutionsFromOrtResult = ortResult.repository.config.resolutions
+            val globalResolutions = context.loadGlobalResolutions(adminConfigService)
+            val resolutionProvider = DefaultResolutionProvider(resolutionsFromOrtResult.merge(globalResolutions))
+
+            val resolvedReporterItems = resolveResolutionsWithMappings(
+                issues = reporterIssuesAsOrt,
+                ruleViolations = emptyList(),
+                vulnerabilities = emptyList(),
+                resolutionProvider = resolutionProvider
+            )
+
             db.dbQuery {
                 ortRunService.storeReporterRun(reporterRun)
                 reporterRunnerResult.resolvedPackageConfigurations?.let {
@@ -127,18 +143,11 @@ internal class ReporterWorker(
                 reporterRunnerResult.issues.takeUnless { it.isEmpty() }?.let {
                     ortRunService.storeIssues(ortRun.id, it)
                 }
+                ortRunService.storeResolvedItems(ortRun.id, resolvedReporterItems)
             }
 
-            val allIssues = reporterRunnerResult.issues
-
-            val repositoryConfigIssueResolutions = ortResult.repository.config.resolutions.issues
-            val globalIssueResolutions = context.loadGlobalResolutions(adminConfigService).issues
-
-            val unresolvedIssues = allIssues
-                .map { issue -> issue.mapToOrt() }
-                .filter { issue ->
-                repositoryConfigIssueResolutions.none { it.matches(issue) } &&
-                        globalIssueResolutions.none { it.matches(issue) }
+            val unresolvedIssues = reporterIssuesAsOrt.filter { issue ->
+                resolutionProvider.getResolutionsFor(issue).isEmpty()
             }
 
             logger.info(

workers/reporter/src/test/kotlin/ReporterRunnerTest.kt

@@ -684,38 +684,28 @@ class ReporterRunnerTest : WordSpec({
             )
         }
 
-        "not return resolvedItems when evaluator ran" {
+        "not return resolvedItems as each worker resolves its own items" {
             val runner = createRunner(config = testReportConfig)
 
             val reporter = reporterFactoryMock(TEST_REPORT_FORMAT)
             mockReporterFactoryAll(TEST_REPORT_FORMAT to reporter)
 
-            val result = runner.run(
+            val resultWithEvaluator = runner.run(
                 ortResult = OrtTestData.result,
                 config = ReporterJobConfiguration(formats = listOf(TEST_REPORT_FORMAT)),
                 evaluatorConfig = EvaluatorJobConfiguration(),
                 mockContext()
             )
 
-            result.resolvedItems should beNull()
-        }
-
-        "return resolvedItems when evaluator did not run" {
-            val runner = createRunner(config = testReportConfig)
-
-            val reporter = reporterFactoryMock(TEST_REPORT_FORMAT)
-            mockReporterFactoryAll(TEST_REPORT_FORMAT to reporter)
-
-            val result = runner.run(
+            val resultWithoutEvaluator = runner.run(
                 ortResult = OrtTestData.result,
                 config = ReporterJobConfiguration(formats = listOf(TEST_REPORT_FORMAT)),
                 evaluatorConfig = null,
                 mockContext()
             )
 
-            result.resolvedItems shouldNot beNull()
-            // resolvedItems should have been computed when evaluator didn't run
-            result.resolvedItems!!.issues.isEmpty() shouldBe false
+            resultWithEvaluator.resolvedItems should beNull()
+            resultWithoutEvaluator.resolvedItems should beNull()
         }
 
         "download asset files" {

workers/reporter/src/test/kotlin/ReporterWorkerTest.kt

@@ -162,6 +162,7 @@ class ReporterWorkerTest : StringSpec({
             every { startReporterJob(REPORTER_JOB_ID) } returns reporterJob
             every { storeIssues(any(), any()) } just runs
             every { storeReporterRun(any()) } just runs
+            every { storeResolvedItems(any(), any()) } just runs
         }
 
         val context = mockk<WorkerContext> {
@@ -279,6 +280,7 @@ class ReporterWorkerTest : StringSpec({
             every { startReporterJob(REPORTER_JOB_ID) } returns reporterJob
             every { storeReporterRun(any()) } just runs
             every { storeIssues(any(), any()) } just runs
+            every { storeResolvedItems(any(), any()) } just runs
             every { generateOrtResult(ortRun, failIfRepoInfoMissing = false) } returns OrtTestData.result
         }
 
@@ -373,6 +375,7 @@ class ReporterWorkerTest : StringSpec({
             every { startReporterJob(REPORTER_JOB_ID) } returns reporterJob
             every { storeReporterRun(any()) } just runs
             every { storeIssues(any(), any()) } just runs
+            every { storeResolvedItems(any(), any()) } just runs
             every { generateOrtResult(ortRun, failIfRepoInfoMissing = false) } returns OrtTestData.result
         }