Fixes #24940: Compliance score are still kept for deleted nodes

webapp/sources/rudder/rudder-core/src/main/scala/com/normation/rudder/score/ScoreRepository.scala

@@ -134,6 +134,6 @@ class ScoreRepositoryImpl(doobie: Doobie) extends ScoreRepository {
     val whereName = scoreId.map(n => fr"scoreId = ${n}")
     val where     = Fragments.whereAndOpt(whereNode, whereName)
     val q         = sql"delete from scoreDetails " ++ where
-    transactIOResult(s"error when getting global score for node ${nodeId.value}")(xa => q.update.run.transact(xa).unit)
+    transactIOResult(s"error when deleting score for node ${nodeId.value}")(xa => q.update.run.transact(xa).unit)
   }
 }

webapp/sources/rudder/rudder-core/src/main/scala/com/normation/rudder/score/ScoreService.scala

@@ -54,6 +54,7 @@ trait ScoreService {
   def registerScore(newScoreId: String, displayName: String): IOResult[Unit]
   def getAvailableScore(): IOResult[List[(String, String)]]
   def init():              IOResult[Unit]
+  def deleteNodeScore(nodeId: NodeId): IOResult[Unit]
 }
 
 class ScoreServiceImpl(globalScoreRepository: GlobalScoreRepository, scoreRepository: ScoreRepository) extends ScoreService {
@@ -126,6 +127,15 @@ class ScoreServiceImpl(globalScoreRepository: GlobalScoreRepository, scoreReposi
     }
   }
 
+  def deleteNodeScore(nodeId: NodeId): IOResult[Unit] = {
+    for {
+      _         <- cache.update(_.removed(nodeId))
+      newScores <- scoreCache.updateAndGet(_.removed(nodeId))
+      _         <- scoreRepository.deleteScore(nodeId, None)
+      _         <- globalScoreRepository.delete(nodeId)
+    } yield {}
+
+  }
   def cleanScore(name: String): IOResult[Unit] = {
     for {
       _         <- cache.update(_.map { case (id, gscore) => (id, gscore.copy(details = gscore.details.filterNot(_.scoreId == name))) })

webapp/sources/rudder/rudder-core/src/main/scala/com/normation/rudder/services/nodes/RemoveNodeService.scala

@@ -68,6 +68,7 @@ import com.normation.rudder.repository.RoNodeGroupRepository
 import com.normation.rudder.repository.UpdateExpectedReportsRepository
 import com.normation.rudder.repository.WoNodeGroupRepository
 import com.normation.rudder.repository.ldap.ScalaReadWriteLock
+import com.normation.rudder.score.ScoreService
 import com.normation.rudder.services.policies.write.NodePoliciesPaths
 import com.normation.rudder.services.policies.write.PathComputer
 import com.normation.rudder.services.servers.DeletionResult.*
@@ -634,6 +635,24 @@ class CleanUpCFKeys extends PostNodeDeleteAction {
   }
 }
 
+class CleanUpNodeScore(scoreService: ScoreService) extends PostNodeDeleteAction {
+  override def run(
+      nodeId: NodeId,
+      mode:   DeleteMode,
+      info:   Option[CoreNodeFact],
+      status: Set[InventoryStatus]
+  )(implicit cc: ChangeContext): UIO[Unit] = {
+    NodeLoggerPure.Delete.debug(s"  - clean-up node '${nodeId.value}' score") *>
+    scoreService
+      .deleteNodeScore(nodeId)
+      .catchAll(err => {
+        NodeLoggerPure.Delete.info(
+          s"Error when cleaning-up scores for node ${(nodeId, info).name}: ${err.fullMsg}"
+        )
+      })
+  }
+}
+
 // clean-up node files on FS
 class CleanUpNodePolicyFiles(varRudderShare: String) extends PostNodeDeleteAction {
   import better.files.*

webapp/sources/rudder/rudder-core/src/test/scala/com/normation/rudder/services/reports/CachedFindRuleNodeStatusReportsTest.scala

@@ -235,6 +235,8 @@ class CachedFindRuleNodeStatusReportsTest extends Specification {
       override def getAvailableScore(): IOResult[List[(String, String)]] = ???
 
       override def init(): IOResult[Unit] = ???
+
+      override def deleteNodeScore(nodeId: NodeId): IOResult[Unit] = ???
     })
 
     override def rulesRepo: RoRuleRepository = new RoRuleRepository {

webapp/sources/rudder/rudder-web/src/main/scala/bootstrap/liftweb/RudderConfig.scala

@@ -3249,6 +3249,7 @@ object RudderConfigInit {
         :: new ResetKeyStatus(rwLdap, removedNodesDitImpl)
         :: new CleanUpCFKeys()
         :: new CleanUpNodePolicyFiles("/var/rudder/share")
+        :: new CleanUpNodeScore(scoreService)
         :: Nil
       )
       .runNow