Merge pull request #14208 from ShvaykaD/feature/propagation-cf

VC import/export for Geofencing CF & CF debug events improvements

application/src/main/java/org/thingsboard/server/actors/calculatedField/CalculatedFieldEntityMessageProcessor.java

@@ -481,6 +481,10 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
                     }
                 }
             } else {
+                if (DebugModeUtil.isDebugFailuresAvailable(ctx.getCalculatedField())) {
+                    String errorMsg = ctx.isInitialized() ? state.getReadinessStatus().errorMsg() : "Calculated field state is not initialized!";
+                    systemContext.persistCalculatedFieldDebugEvent(tenantId, ctx.getCfId(), entityId, state.getArguments(), tbMsgId, tbMsgType, null,  errorMsg);
+                }
                 callback.onSuccess();
             }
         } catch (Exception e) {

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/BaseCalculatedFieldState.java

@@ -27,6 +27,7 @@ import org.thingsboard.server.service.cf.ctx.state.aggregation.RelatedEntitiesAr
 import org.thingsboard.server.utils.CalculatedFieldUtils;
 
 import java.io.Closeable;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -43,6 +44,7 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
     protected Map<String, ArgumentEntry> arguments = new HashMap<>();
     protected boolean sizeExceedsLimit;
     protected long latestTimestamp = -1;
+    protected ReadinessStatus readinessStatus;
 
     @Setter
     private TopicPartitionInfo partition;
@@ -56,6 +58,7 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
         this.ctx = ctx;
         this.actorCtx = actorCtx;
         this.requiredArguments = ctx.getArgNames();
+        this.readinessStatus = checkReadiness(requiredArguments, arguments);
     }
 
     @Override
@@ -98,8 +101,9 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
         }
 
         if (updatedArguments == null) {
-            updatedArguments = Collections.emptyMap();
+            return Collections.emptyMap();
         }
+        readinessStatus = checkReadiness(requiredArguments, arguments);
         return updatedArguments;
     }
 
@@ -113,8 +117,7 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
 
     @Override
     public boolean isReady() {
-        return arguments.keySet().containsAll(requiredArguments) &&
-                arguments.values().stream().noneMatch(ArgumentEntry::isEmpty);
+        return readinessStatus.ready();
     }
 
     @Override
@@ -157,4 +160,21 @@ public abstract class BaseCalculatedFieldState implements CalculatedFieldState,
         this.latestTimestamp = Math.max(this.latestTimestamp, newTs);
     }
 
+    protected ReadinessStatus checkReadiness(List<String> requiredArguments, Map<String, ArgumentEntry> currentArguments) {
+        if (currentArguments == null) {
+            return ReadinessStatus.from(requiredArguments);
+        }
+        List<String> emptyArguments = null;
+        for (String requiredArgumentKey : requiredArguments) {
+            ArgumentEntry argumentEntry = currentArguments.get(requiredArgumentKey);
+            if (argumentEntry == null || argumentEntry.isEmpty()) {
+                if (emptyArguments == null) {
+                    emptyArguments = new ArrayList<>();
+                }
+                emptyArguments.add(requiredArgumentKey);
+            }
+        }
+        return ReadinessStatus.from(emptyArguments);
+    }
+
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/CalculatedFieldState.java

@@ -23,6 +23,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.actors.TbActorRef;
 import org.thingsboard.server.common.data.cf.CalculatedFieldType;
 import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.util.CollectionsUtil;
 import org.thingsboard.server.common.msg.queue.TopicPartitionInfo;
 import org.thingsboard.server.service.cf.CalculatedFieldResult;
 import org.thingsboard.server.service.cf.ctx.CalculatedFieldEntityCtxId;
@@ -33,6 +34,7 @@ import org.thingsboard.server.service.cf.ctx.state.geofencing.GeofencingCalculat
 import org.thingsboard.server.service.cf.ctx.state.propagation.PropagationCalculatedFieldState;
 
 import java.io.Closeable;
+import java.util.List;
 import java.util.Map;
 
 import static org.thingsboard.server.utils.CalculatedFieldUtils.toSingleValueArgumentProto;
@@ -70,6 +72,8 @@ public interface CalculatedFieldState extends Closeable {
     @JsonIgnore
     boolean isReady();
 
+    ReadinessStatus getReadinessStatus();
+
     boolean isSizeExceedsLimit();
 
     @JsonIgnore
@@ -94,4 +98,17 @@ public interface CalculatedFieldState extends Closeable {
         }
     }
 
+    record ReadinessStatus(boolean ready, String errorMsg) {
+
+        private static final String ERROR_MESSAGE = "Required arguments are missing: ";
+        private static final ReadinessStatus READY = new ReadinessStatus(true, null);
+
+        public static ReadinessStatus from(List<String> emptyOrMissingArguments) {
+            if (CollectionsUtil.isEmpty(emptyOrMissingArguments)) {
+                return ReadinessStatus.READY;
+            }
+            return new ReadinessStatus(false, ERROR_MESSAGE + String.join(", ", emptyOrMissingArguments));
+        }
+    }
+
 }

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/SingleValueArgumentEntry.java

@@ -134,6 +134,9 @@ public class SingleValueArgumentEntry implements ArgumentEntry {
 
     @Override
     public TbelCfArg toTbelCfArg() {
+        if (isEmpty()) {
+            return new TbelCfSingleValueArg(ts, null);
+        }
         Object value = kvEntryValue.getValue();
         if (kvEntryValue instanceof JsonDataEntry) {
             try {

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/propagation/PropagationArgumentEntry.java

@@ -23,6 +23,7 @@ import org.thingsboard.server.common.data.util.CollectionsUtil;
 import org.thingsboard.server.service.cf.ctx.state.ArgumentEntry;
 import org.thingsboard.server.service.cf.ctx.state.ArgumentEntryType;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Data
@@ -33,7 +34,7 @@ public class PropagationArgumentEntry implements ArgumentEntry {
     private boolean forceResetPrevious;
 
     public PropagationArgumentEntry(List<EntityId> propagationEntityIds) {
-        this.propagationEntityIds = propagationEntityIds;
+        this.propagationEntityIds = new ArrayList<>(propagationEntityIds);
     }
 
     @Override

application/src/main/java/org/thingsboard/server/service/cf/ctx/state/propagation/PropagationCalculatedFieldState.java

@@ -33,6 +33,7 @@ import org.thingsboard.server.service.cf.ctx.state.CalculatedFieldCtx;
 import org.thingsboard.server.service.cf.ctx.state.ScriptCalculatedFieldState;
 import org.thingsboard.server.service.cf.ctx.state.SingleValueArgumentEntry;
 
+import java.util.ArrayList;
 import java.util.Map;
 
 import static org.thingsboard.server.common.data.cf.configuration.PropagationCalculatedFieldConfiguration.PROPAGATION_CONFIG_ARGUMENT;
@@ -47,21 +48,14 @@ public class PropagationCalculatedFieldState extends ScriptCalculatedFieldState
     public void setCtx(CalculatedFieldCtx ctx, TbActorRef actorCtx) {
         this.ctx = ctx;
         this.actorCtx = actorCtx;
-        this.requiredArguments = ctx.getArgNames();
+        this.requiredArguments = new ArrayList<>(ctx.getArgNames());
+        requiredArguments.add(PROPAGATION_CONFIG_ARGUMENT);
+        this.readinessStatus = checkReadiness(requiredArguments, arguments);
         if (ctx.isApplyExpressionForResolvedArguments()) {
             this.tbelExpression = ctx.getTbelExpressions().get(ctx.getExpression());
         }
     }
 
-    @Override
-    public boolean isReady() {
-        if (!super.isReady()) {
-            return false;
-        }
-        ArgumentEntry propagationArg = arguments.get(PROPAGATION_CONFIG_ARGUMENT);
-        return propagationArg != null && !propagationArg.isEmpty();
-    }
-
     @Override
     public CalculatedFieldType getType() {
         return CalculatedFieldType.PROPAGATION;

application/src/main/java/org/thingsboard/server/service/sync/ie/exporting/impl/DefaultEntityExportService.java

@@ -25,6 +25,7 @@ import org.thingsboard.server.common.data.ExportableEntity;
 import org.thingsboard.server.common.data.HasVersion;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.configuration.ArgumentsBasedCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.cf.configuration.geofencing.GeofencingCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
@@ -154,12 +155,20 @@ public class DefaultEntityExportService<I extends EntityId, E extends Exportable
         List<CalculatedField> calculatedFields = calculatedFieldService.findCalculatedFieldsByEntityId(ctx.getTenantId(), entityId);
         calculatedFields.forEach(calculatedField -> {
             calculatedField.setEntityId(getExternalIdOrElseInternal(ctx, entityId));
-            if (calculatedField.getConfiguration() instanceof ArgumentsBasedCalculatedFieldConfiguration configuration) {
-                configuration.getArguments().values().forEach(argument -> {
-                    if (argument.getRefEntityId() != null) {
-                        argument.setRefEntityId(getExternalIdOrElseInternal(ctx, argument.getRefEntityId()));
-                    }
-                });
+            if (calculatedField.getConfiguration() instanceof ArgumentsBasedCalculatedFieldConfiguration argBasedConfig) {
+                if (argBasedConfig instanceof GeofencingCalculatedFieldConfiguration geofencingCfg) {
+                    geofencingCfg.getZoneGroups().values().forEach(zoneGroupConfiguration -> {
+                        if (zoneGroupConfiguration.getRefEntityId() != null) {
+                            zoneGroupConfiguration.setRefEntityId(getExternalIdOrElseInternal(ctx, zoneGroupConfiguration.getRefEntityId()));
+                        }
+                    });
+                } else {
+                    argBasedConfig.getArguments().values().forEach(argument -> {
+                        if (argument.getRefEntityId() != null) {
+                            argument.setRefEntityId(getExternalIdOrElseInternal(ctx, argument.getRefEntityId()));
+                        }
+                    });
+                }
             }
         });
         return calculatedFields;

application/src/main/java/org/thingsboard/server/service/sync/ie/importing/impl/BaseEntityImportService.java

@@ -36,6 +36,7 @@ import org.thingsboard.server.common.data.User;
 import org.thingsboard.server.common.data.audit.ActionType;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.configuration.ArgumentsBasedCalculatedFieldConfiguration;
+import org.thingsboard.server.common.data.cf.configuration.geofencing.GeofencingCalculatedFieldConfiguration;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityIdFactory;
@@ -322,12 +323,20 @@ public abstract class BaseEntityImportService<I extends EntityId, E extends Expo
                 .peek(calculatedField -> {
                     calculatedField.setTenantId(ctx.getTenantId());
                     calculatedField.setEntityId(savedEntity.getId());
-                    if (calculatedField.getConfiguration() instanceof ArgumentsBasedCalculatedFieldConfiguration configuration) {
-                        configuration.getArguments().values().forEach(argument -> {
-                            if (argument.getRefEntityId() != null) {
-                                argument.setRefEntityId(idProvider.getInternalId(argument.getRefEntityId(), ctx.isFinalImportAttempt()));
-                            }
-                        });
+                    if (calculatedField.getConfiguration() instanceof ArgumentsBasedCalculatedFieldConfiguration argBasedConfig) {
+                        if (argBasedConfig instanceof GeofencingCalculatedFieldConfiguration geofencingCfg) {
+                            geofencingCfg.getZoneGroups().values().forEach(zoneGroupConfiguration -> {
+                                if (zoneGroupConfiguration.getRefEntityId() != null) {
+                                    zoneGroupConfiguration.setRefEntityId(idProvider.getInternalId(zoneGroupConfiguration.getRefEntityId(), ctx.isFinalImportAttempt()));
+                                }
+                            });
+                        } else {
+                            argBasedConfig.getArguments().values().forEach(argument -> {
+                                if (argument.getRefEntityId() != null) {
+                                    argument.setRefEntityId(idProvider.getInternalId(argument.getRefEntityId(), ctx.isFinalImportAttempt()));
+                                }
+                            });
+                        }
                     }
                 }).toList();
 

application/src/test/java/org/thingsboard/server/service/cf/ctx/state/GeofencingCalculatedFieldStateTest.java

@@ -200,31 +200,31 @@ public class GeofencingCalculatedFieldStateTest {
     @Test
     void testIsReadyWhenNotAllArgPresent() {
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains(state.getRequiredArguments());
     }
 
     @Test
     void testIsReadyWhenAllArgPresent() {
-        state.arguments = new HashMap<>(Map.of(
+        state.update(Map.of(
                 ENTITY_ID_LATITUDE_ARGUMENT_KEY, latitudeArgEntry,
                 ENTITY_ID_LONGITUDE_ARGUMENT_KEY, longitudeArgEntry,
                 "allowedZones", geofencingAllowedZoneArgEntry,
                 "restrictedZones", geofencingRestrictedZoneArgEntry
-        ));
+        ), ctx);
         assertThat(state.isReady()).isTrue();
+        assertThat(state.getReadinessStatus().errorMsg()).isNull();
     }
 
     @Test
     void testIsReadyWhenEmptyEntryPresents() {
-        state.arguments = new HashMap<>(Map.of(
+        state.update(Map.of(
                 ENTITY_ID_LATITUDE_ARGUMENT_KEY, latitudeArgEntry,
                 ENTITY_ID_LONGITUDE_ARGUMENT_KEY, longitudeArgEntry,
                 "allowedZones", geofencingAllowedZoneArgEntry,
-                "restrictedZones", geofencingRestrictedZoneArgEntry
-        ));
-
-        state.getArguments().put("noParkingZones", new GeofencingArgumentEntry());
-
+                "restrictedZones", new GeofencingArgumentEntry()
+        ), ctx);
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains("restrictedZones");
     }
 
     @Test

application/src/test/java/org/thingsboard/server/service/cf/ctx/state/PropagationArgumentEntryTest.java

@@ -57,12 +57,6 @@ public class PropagationArgumentEntryTest {
         assertThat(emptyEntry.isEmpty()).isTrue();
     }
 
-    @Test
-    void testIsEmptyWhenNullList() {
-        PropagationArgumentEntry nullListEntry = new PropagationArgumentEntry(null);
-        assertThat(nullListEntry.isEmpty()).isTrue();
-    }
-
     @Test
     void testGetValueReturnsPropagationIds() {
         assertThat(entry.getValue()).isInstanceOf(List.class);
@@ -106,16 +100,6 @@ public class PropagationArgumentEntryTest {
         assertThat(entry.getPropagationEntityIds()).isEmpty();
     }
 
-    @Test
-    void testUpdateEntryClearsWhenNewEntryIsNullList() {
-        var updatedNull = new PropagationArgumentEntry(null);
-
-        boolean changed = entry.updateEntry(updatedNull);
-
-        assertThat(changed).isTrue();
-        assertThat(entry.getPropagationEntityIds()).isEmpty();
-    }
-
     @Test
     @SuppressWarnings("unchecked")
     void testToTbelCfArgWithValues() {

application/src/test/java/org/thingsboard/server/service/cf/ctx/state/PropagationCalculatedFieldStateTest.java

@@ -117,7 +117,7 @@ public class PropagationCalculatedFieldStateTest {
     @Test
     void testInitAddsRequiredArgument() {
         initCtxAndState(false);
-        assertThat(state.getRequiredArguments()).containsExactlyInAnyOrder(TEMPERATURE_ARGUMENT_NAME);
+        assertThat(state.getRequiredArguments()).containsExactlyInAnyOrder(TEMPERATURE_ARGUMENT_NAME, PROPAGATION_CONFIG_ARGUMENT);
     }
 
     @Test
@@ -129,24 +129,26 @@ public class PropagationCalculatedFieldStateTest {
     @Test
     void testIsReadyWhenPropagationArgIsNull() {
         initCtxAndState(false);
-        state.getArguments().put(TEMPERATURE_ARGUMENT_NAME, singleValueArgEntry);
+        state.update(Map.of(TEMPERATURE_ARGUMENT_NAME, singleValueArgEntry), ctx);
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains(PROPAGATION_CONFIG_ARGUMENT);
     }
 
     @Test
     void testIsReadyWhenPropagationArgIsEmpty() {
         initCtxAndState(false);
-        state.getArguments().put(TEMPERATURE_ARGUMENT_NAME, singleValueArgEntry);
-        state.getArguments().put(PROPAGATION_CONFIG_ARGUMENT, new PropagationArgumentEntry(Collections.emptyList()));
+        state.update(Map.of(TEMPERATURE_ARGUMENT_NAME, singleValueArgEntry,
+                PROPAGATION_CONFIG_ARGUMENT, new PropagationArgumentEntry(Collections.emptyList())), ctx);
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains(PROPAGATION_CONFIG_ARGUMENT);
     }
 
     @Test
     void testIsReadyWhenPropagationArgHasEntities() {
         initCtxAndState(false);
-        state.getArguments().put(TEMPERATURE_ARGUMENT_NAME, singleValueArgEntry);
-        state.getArguments().put(PROPAGATION_CONFIG_ARGUMENT, propagationArgEntry);
+        state.update(Map.of(TEMPERATURE_ARGUMENT_NAME, singleValueArgEntry, PROPAGATION_CONFIG_ARGUMENT, propagationArgEntry), ctx);
         assertThat(state.isReady()).isTrue();
+        assertThat(state.getReadinessStatus().errorMsg()).isNull();
     }
 
 

application/src/test/java/org/thingsboard/server/service/cf/ctx/state/ScriptCalculatedFieldStateTest.java

@@ -161,20 +161,21 @@ public class ScriptCalculatedFieldStateTest {
     @Test
     void testIsReadyWhenNotAllArgPresent() {
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains(state.getRequiredArguments());
     }
 
     @Test
     void testIsReadyWhenAllArgPresent() {
-        state.arguments = new HashMap<>(Map.of("deviceTemperature", deviceTemperatureArgEntry, "assetHumidity", assetHumidityArgEntry));
-
+        state.update(Map.of("deviceTemperature", deviceTemperatureArgEntry, "assetHumidity", assetHumidityArgEntry), ctx);
         assertThat(state.isReady()).isTrue();
+        assertThat(state.getReadinessStatus().errorMsg()).isNull();
     }
 
     @Test
     void testIsReadyWhenEmptyEntryPresents() {
-        state.arguments = new HashMap<>(Map.of("deviceTemperature", new TsRollingArgumentEntry(5, 30000L), "assetHumidity", assetHumidityArgEntry));
-
+        state.update(Map.of("deviceTemperature", new TsRollingArgumentEntry(5, 30000L), "assetHumidity", assetHumidityArgEntry), ctx);
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains("deviceTemperature");
     }
 
     private TsRollingArgumentEntry createRollingArgEntry() {

application/src/test/java/org/thingsboard/server/service/cf/ctx/state/SimpleCalculatedFieldStateTest.java

@@ -204,28 +204,29 @@ public class SimpleCalculatedFieldStateTest {
     @Test
     void testIsReadyWhenNotAllArgPresent() {
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains(state.getRequiredArguments());
     }
 
     @Test
     void testIsReadyWhenAllArgPresent() {
-        state.arguments = new HashMap<>(Map.of(
+        state.update(Map.of(
                 "key1", key1ArgEntry,
                 "key2", key2ArgEntry,
                 "key3", key3ArgEntry
-        ));
-
+        ), ctx);
         assertThat(state.isReady()).isTrue();
+        assertThat(state.getReadinessStatus().errorMsg()).isNull();
     }
 
     @Test
     void testIsReadyWhenEmptyEntryPresents() {
-        state.arguments = new HashMap<>(Map.of(
+        state.update(Map.of(
                 "key1", key1ArgEntry,
-                "key2", key2ArgEntry
-        ));
-        state.getArguments().put("key3", new SingleValueArgumentEntry());
-
+                "key2", key2ArgEntry,
+                "key3", new SingleValueArgumentEntry()
+        ), ctx);
         assertThat(state.isReady()).isFalse();
+        assertThat(state.getReadinessStatus().errorMsg()).contains("key3");
     }
 
     private CalculatedField getCalculatedField() {

application/src/test/java/org/thingsboard/server/utils/CalculatedFieldUtilsTest.java

@@ -47,6 +47,7 @@ import java.util.UUID;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 import static org.thingsboard.server.common.data.cf.configuration.PropagationCalculatedFieldConfiguration.PROPAGATION_CONFIG_ARGUMENT;
 import static org.thingsboard.server.utils.CalculatedFieldUtils.toProto;
 
@@ -91,14 +92,22 @@ class CalculatedFieldUtilsTest {
 
         // Create cf state with the geofencing argument and add it to the state map
         CalculatedFieldState state = new GeofencingCalculatedFieldState(DEVICE_ID);
-        state.update(Map.of("geofencingArgumentTest", geofencingArgumentEntry), mock(CalculatedFieldCtx.class));
+
+        CalculatedFieldCtx cfCtxMock = mock(CalculatedFieldCtx.class);
+        when(cfCtxMock.getArgNames()).thenReturn(List.of("geofencingArgumentTest"));
+
+        state.setCtx(cfCtxMock, null);
+
+        Map<String, ArgumentEntry> updatedArguments = state.update(Map.of("geofencingArgumentTest", geofencingArgumentEntry), cfCtxMock);
+        assertThat(updatedArguments).hasSize(1);
+        assertThat(updatedArguments.get("geofencingArgumentTest")).isEqualTo(geofencingArgumentEntry);
 
         CalculatedFieldStateProto proto = toProto(stateId, state);
         CalculatedFieldState fromProto = CalculatedFieldUtils.fromProto(stateId, proto);
 
         assertThat(fromProto)
                 .usingRecursiveComparison()
-                .ignoringFields("requiredArguments")
+                .ignoringFields("ctx", "requiredArguments", "readinessStatus")
                 .isEqualTo(state);
 
         ArgumentEntry fromProtoArgument = fromProto.getArguments().get("geofencingArgumentTest");
@@ -124,9 +133,16 @@ class CalculatedFieldUtilsTest {
         SingleValueArgumentEntry singleValueArgumentEntry = new SingleValueArgumentEntry(new BaseAttributeKvEntry(new StringDataEntry("state", "active"), lastUpdateTs, 1L));
 
         CalculatedFieldCtx cfCtxMock = mock(CalculatedFieldCtx.class);
+        when(cfCtxMock.getArgNames()).thenReturn(List.of("state"));
 
         CalculatedFieldState state = new PropagationCalculatedFieldState(DEVICE_ID);
-        state.update(Map.of(PROPAGATION_CONFIG_ARGUMENT, propagationArgumentEntry, "state", singleValueArgumentEntry), cfCtxMock);
+
+        state.setCtx(cfCtxMock, null);
+
+        Map<String, ArgumentEntry> updatedArguments = state.update(Map.of(PROPAGATION_CONFIG_ARGUMENT, propagationArgumentEntry, "state", singleValueArgumentEntry), cfCtxMock);
+        assertThat(updatedArguments).hasSize(2);
+        assertThat(updatedArguments.get(PROPAGATION_CONFIG_ARGUMENT)).isEqualTo(propagationArgumentEntry);
+        assertThat(updatedArguments.get("state")).isEqualTo(singleValueArgumentEntry);
 
         // when
         CalculatedFieldStateProto proto = toProto(stateId, state);
@@ -144,6 +160,8 @@ class CalculatedFieldUtilsTest {
         assertThat(propagationState.getArguments()).isNotNull();
         assertThat(propagationState.getArguments().get(PROPAGATION_CONFIG_ARGUMENT)).isNull();
         assertThat(propagationState.getArguments().get("state")).isNotNull().isEqualTo(singleValueArgumentEntry);
+        assertThat(propagationState.getRequiredArguments()).isNull();
+        assertThat(propagationState.getReadinessStatus()).isNull();
     }
 
 }