This is an automated email from the ASF dual-hosted git repository.

sergehuber pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/unomi.git


The following commit(s) were added to refs/heads/master by this push:
     new e18782bd1 UNOMI-1065: Handle scorings with no elements when loading 
dependent metadata (#966)
e18782bd1 is described below

commit e18782bd163104b6670361a03d2dd1f70a683e42
Author: Serge Huber <[email protected]>
AuthorDate: Sun Nov 15 10:40:48 2026 +0100

    UNOMI-1065: Handle scorings with no elements when loading dependent 
metadata (#966)
---
 .../services/impl/segments/SegmentServiceImpl.java | 22 ++++++++--
 .../impl/segments/SegmentServiceImplTest.java      | 47 ++++++++++++++++++++++
 2 files changed, 65 insertions(+), 4 deletions(-)

diff --git 
a/services/src/main/java/org/apache/unomi/services/impl/segments/SegmentServiceImpl.java
 
b/services/src/main/java/org/apache/unomi/services/impl/segments/SegmentServiceImpl.java
index d91fd9e94..a2686b360 100644
--- 
a/services/src/main/java/org/apache/unomi/services/impl/segments/SegmentServiceImpl.java
+++ 
b/services/src/main/java/org/apache/unomi/services/impl/segments/SegmentServiceImpl.java
@@ -510,7 +510,7 @@ public class SegmentServiceImpl extends 
AbstractMultiTypeCachingService implemen
         Set<Scoring> impactedScorings = new HashSet<>();
         if (tenantScoring != null) {
             for (Scoring scoring : tenantScoring.values()) {
-                if 
(checkSegmentDeletionImpact(scoring.getElements().get(0).getCondition(), 
segmentId)) {
+                if 
(checkSegmentDeletionImpact(firstScoringElementCondition(scoring), segmentId)) {
                     impactedScorings.add(scoring);
                 }
             }
@@ -536,7 +536,7 @@ public class SegmentServiceImpl extends 
AbstractMultiTypeCachingService implemen
 
         if (tenantScoring != null) {
             for (Scoring scoring : tenantScoring.values()) {
-                if 
(checkSegmentDeletionImpact(scoring.getElements().get(0).getCondition(), 
segmentId)) {
+                if 
(checkSegmentDeletionImpact(firstScoringElementCondition(scoring), segmentId)) {
                     scorings.add(scoring.getMetadata());
                 }
             }
@@ -899,7 +899,7 @@ public class SegmentServiceImpl extends 
AbstractMultiTypeCachingService implemen
         Set<Scoring> impactedScorings = new HashSet<>();
         if (tenantScoring != null) {
             for (Scoring scoring : tenantScoring.values()) {
-                if 
(checkScoringDeletionImpact(scoring.getElements().get(0).getCondition(), 
scoringId)) {
+                if 
(checkScoringDeletionImpact(firstScoringElementCondition(scoring), scoringId)) {
                     impactedScorings.add(scoring);
                 }
             }
@@ -907,6 +907,20 @@ public class SegmentServiceImpl extends 
AbstractMultiTypeCachingService implemen
         return impactedScorings;
     }
 
+    /**
+     * Condition used when checking whether a scoring depends on another 
definition.
+     * Scorings with no elements (for example form-style create) have nothing 
to check.
+     * UNOMI-1065.
+     */
+    private Condition firstScoringElementCondition(Scoring scoring) {
+        List<ScoringElement> elements = scoring.getElements();
+        if (elements == null || elements.isEmpty()) {
+            return null;
+        }
+        ScoringElement first = elements.get(0);
+        return first != null ? first.getCondition() : null;
+    }
+
     public DependentMetadata getScoringDependentMetadata(String scoringId) {
         List<Metadata> segments = new ArrayList<>();
         List<Metadata> scorings = new ArrayList<>();
@@ -925,7 +939,7 @@ public class SegmentServiceImpl extends 
AbstractMultiTypeCachingService implemen
 
         if (tenantScoring != null) {
             for (Scoring scoring : tenantScoring.values()) {
-                if 
(checkScoringDeletionImpact(scoring.getElements().get(0).getCondition(), 
scoringId)) {
+                if 
(checkScoringDeletionImpact(firstScoringElementCondition(scoring), scoringId)) {
                     scorings.add(scoring.getMetadata());
                 }
             }
diff --git 
a/services/src/test/java/org/apache/unomi/services/impl/segments/SegmentServiceImplTest.java
 
b/services/src/test/java/org/apache/unomi/services/impl/segments/SegmentServiceImplTest.java
index a127beed7..010b7f7ac 100644
--- 
a/services/src/test/java/org/apache/unomi/services/impl/segments/SegmentServiceImplTest.java
+++ 
b/services/src/test/java/org/apache/unomi/services/impl/segments/SegmentServiceImplTest.java
@@ -26,7 +26,9 @@ import org.apache.unomi.api.conditions.ConditionType;
 import org.apache.unomi.api.exceptions.BadSegmentConditionException;
 import org.apache.unomi.api.query.Query;
 import org.apache.unomi.api.rules.Rule;
+import org.apache.unomi.api.segments.DependentMetadata;
 import org.apache.unomi.api.segments.Scoring;
+import org.apache.unomi.api.segments.ScoringElement;
 import org.apache.unomi.api.segments.Segment;
 import org.apache.unomi.api.segments.SegmentsAndScores;
 import org.apache.unomi.api.services.EventService;
@@ -1402,5 +1404,50 @@ public class SegmentServiceImplTest {
             return null;
         });
     }
+
+    /**
+     * UNOMI-1065: scorings with an empty or null element list must not break
+     * dependent-metadata walks that previously assumed elements.get(0) always 
exists.
+     */
+    @Test
+    public void testDependentMetadataToleratesScoringWithNoElements() {
+        executionContextManager.executeAsTenant(TENANT_1, () -> {
+            // Form-style create uses an empty list (not null).
+            Scoring emptyElements = createTestScoring("empty-elements-score", 
"Empty Elements");
+            emptyElements.setElements(Collections.emptyList());
+            segmentService.setScoringDefinition(emptyElements);
+
+            Scoring withElements = createTestScoring("with-elements-score", 
"With Elements");
+            ScoringElement element = new ScoringElement();
+            element.setCondition(new 
Condition(definitionsService.getConditionType("matchAllCondition")));
+            element.setValue(1);
+            withElements.setElements(Collections.singletonList(element));
+            segmentService.setScoringDefinition(withElements);
+            persistenceService.refresh();
+
+            // Walks all scorings, including the empty-elements one.
+            DependentMetadata forScoring = 
segmentService.getScoringDependentMetadata("with-elements-score");
+            assertNotNull(forScoring);
+            assertTrue(forScoring.getSegments().isEmpty());
+            assertTrue(forScoring.getScorings().isEmpty());
+
+            DependentMetadata forEmpty = 
segmentService.getScoringDependentMetadata("empty-elements-score");
+            assertNotNull(forEmpty);
+
+            DependentMetadata forSegment = 
segmentService.getSegmentDependentMetadata("does-not-exist");
+            assertNotNull(forSegment);
+            assertTrue(forSegment.getSegments().isEmpty());
+            assertTrue(forSegment.getScorings().isEmpty());
+
+            // Null elements on a live cached scoring (same walk path).
+            Scoring cachedEmpty = 
segmentService.getScoringDefinition("empty-elements-score");
+            cachedEmpty.setElements(null);
+            DependentMetadata afterNull = 
segmentService.getScoringDependentMetadata("with-elements-score");
+            assertNotNull(afterNull);
+            DependentMetadata afterNullSegment = 
segmentService.getSegmentDependentMetadata("does-not-exist");
+            assertNotNull(afterNullSegment);
+            return null;
+        });
+    }
 }
 

Reply via email to