Merge pull request #14535 from irynamatveieva/cf-output

Calculated fields update fixes

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

@@ -159,10 +159,14 @@ public class CalculatedFieldEntityMessageProcessor extends AbstractContextAwareM
             } else {
                 state.setCtx(ctx, actorCtx);
             }
-            if (state.isSizeOk()) {
-                processStateIfReady(state, Collections.emptyMap(), ctx, Collections.singletonList(ctx.getCfId()), null, null, msg.getCallback());
+            if (msg.getStateAction() != StateAction.REFRESH_CTX) {
+                if (state.isSizeOk()) {
+                    processStateIfReady(state, Collections.emptyMap(), ctx, Collections.singletonList(ctx.getCfId()), null, null, msg.getCallback());
+                } else {
+                    throw new RuntimeException(ctx.getSizeExceedsLimitMessage());
+                }
             } else {
-                throw new RuntimeException(ctx.getSizeExceedsLimitMessage());
+                msg.getCallback().onSuccess();
             }
         } catch (Exception e) {
             log.debug("[{}][{}] Failed to initialize CF state", entityId, ctx.getCfId(), e);

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

@@ -462,6 +462,8 @@ public class CalculatedFieldManagerMessageProcessor extends AbstractContextAware
                     stateAction = StateAction.REINIT; // refetch arguments, call state.init, then calculate
                 } else if (newCfCtx.hasContextOnlyChanges(oldCfCtx)) {
                     stateAction = StateAction.REPROCESS; // call state.setCtx, then calculate
+                } else if (newCfCtx.hasRefreshContextOnlyChanges(oldCfCtx)) {
+                    stateAction = StateAction.REFRESH_CTX;
                 } else {
                     callback.onSuccess();
                     return;

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

@@ -39,6 +39,7 @@ public class EntityInitCalculatedFieldMsg implements ToCalculatedFieldSystemMsg
         INIT,
         REINIT,
         RECREATE,
-        REPROCESS
+        REPROCESS,
+        REFRESH_CTX
     }
 }

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

@@ -636,16 +636,33 @@ public class CalculatedFieldCtx implements Closeable {
         return new CalculatedFieldEntityCtxId(tenantId, cfId, entityId);
     }
 
+    public boolean hasRefreshContextOnlyChanges(CalculatedFieldCtx other) { // has changes that do not require state recalculation
+        var thisOutputStrategy = calculatedField.getConfiguration().getOutput().getStrategy();
+        var otherOutputStrategy = other.getCalculatedField().getConfiguration().getOutput().getStrategy();
+        if (thisOutputStrategy.hasRefreshContextOnlyChanges(otherOutputStrategy)) {
+            return true;
+        }
+
+        if (calculatedField.getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration thisConfig
+                && other.getCalculatedField().getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration otherConfig) {
+            if (thisConfig.isProduceIntermediateResult() != otherConfig.isProduceIntermediateResult()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     public boolean hasContextOnlyChanges(CalculatedFieldCtx other) { // has changes that do not require state reinit and will be picked up by the state on the fly
         if (calculatedField.getConfiguration() instanceof ExpressionBasedCalculatedFieldConfiguration && !Objects.equals(expression, other.expression)) {
             return true;
         }
-        if (!Objects.equals(output, other.output)) {
+        if (output.hasContextOnlyChanges(other.output)) {
             return true;
         }
         if (calculatedField.getConfiguration() instanceof SimpleCalculatedFieldConfiguration thisConfig
-            && other.calculatedField.getConfiguration() instanceof SimpleCalculatedFieldConfiguration otherConfig
-            && thisConfig.isUseLatestTs() != otherConfig.isUseLatestTs()) {
+                && other.calculatedField.getConfiguration() instanceof SimpleCalculatedFieldConfiguration otherConfig
+                && thisConfig.isUseLatestTs() != otherConfig.isUseLatestTs()) {
             return true;
         }
         if (cfType == CalculatedFieldType.ALARM) {
@@ -667,18 +684,19 @@ public class CalculatedFieldCtx implements Closeable {
             return true;
         }
         if (calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration thisConfig
-            && other.getCalculatedField().getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration otherConfig
-            && (thisConfig.getDeduplicationIntervalInSec() != otherConfig.getDeduplicationIntervalInSec()
+                && other.getCalculatedField().getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration otherConfig
+                && (thisConfig.getDeduplicationIntervalInSec() != otherConfig.getDeduplicationIntervalInSec()
                 || !thisConfig.getMetrics().equals(otherConfig.getMetrics())
                 || thisConfig.isUseLatestTs() != otherConfig.isUseLatestTs())) {
             return true;
         }
         if (calculatedField.getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration thisConfig
-            && other.getCalculatedField().getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration otherConfig) {
+                && other.getCalculatedField().getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration otherConfig) {
             boolean metricsChanged = !Objects.equals(thisConfig.getMetrics(), otherConfig.getMetrics());
             boolean watermarkChanged = !Objects.equals(thisConfig.getWatermark(), otherConfig.getWatermark());
-            boolean produceIntermediateResultChanged = thisConfig.isProduceIntermediateResult() != otherConfig.isProduceIntermediateResult();
-            return metricsChanged || watermarkChanged || produceIntermediateResultChanged;
+            if (metricsChanged || watermarkChanged) {
+                return true;
+            }
         }
         return false;
     }
@@ -711,7 +729,7 @@ public class CalculatedFieldCtx implements Closeable {
 
     private boolean hasGeofencingZoneGroupConfigurationChanges(CalculatedFieldCtx other) {
         if (calculatedField.getConfiguration() instanceof GeofencingCalculatedFieldConfiguration thisConfig
-            && other.calculatedField.getConfiguration() instanceof GeofencingCalculatedFieldConfiguration otherConfig) {
+                && other.calculatedField.getConfiguration() instanceof GeofencingCalculatedFieldConfiguration otherConfig) {
             return !thisConfig.getZoneGroups().equals(otherConfig.getZoneGroups());
         }
         return false;
@@ -719,7 +737,7 @@ public class CalculatedFieldCtx implements Closeable {
 
     private boolean hasRelatedEntitiesAggregationConfigurationChanges(CalculatedFieldCtx other) {
         if (calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration thisConfig
-            && other.calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration otherConfig) {
+                && other.calculatedField.getConfiguration() instanceof RelatedEntitiesAggregationCalculatedFieldConfiguration otherConfig) {
             return !thisConfig.getRelation().equals(otherConfig.getRelation());
         }
         return false;
@@ -727,7 +745,7 @@ public class CalculatedFieldCtx implements Closeable {
 
     private boolean hasEntityAggregationConfigurationChanges(CalculatedFieldCtx other) {
         if (calculatedField.getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration thisConfig
-            && other.calculatedField.getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration otherConfig) {
+                && other.calculatedField.getConfiguration() instanceof EntityAggregationCalculatedFieldConfiguration otherConfig) {
             return !thisConfig.getInterval().equals(otherConfig.getInterval());
         }
         return false;
@@ -752,7 +770,7 @@ public class CalculatedFieldCtx implements Closeable {
                     yield true;
                 }
                 yield geofencingState.getLastDynamicArgumentsRefreshTs() <
-                      System.currentTimeMillis() - scheduledUpdateIntervalMillis;
+                        System.currentTimeMillis() - scheduledUpdateIntervalMillis;
             }
             default -> false;
         };
@@ -796,10 +814,10 @@ public class CalculatedFieldCtx implements Closeable {
     @Override
     public String toString() {
         return "CalculatedFieldCtx{" +
-               "cfId=" + cfId +
-               ", cfType=" + cfType +
-               ", entityId=" + entityId +
-               '}';
+                "cfId=" + cfId +
+                ", cfType=" + cfType +
+                ", entityId=" + entityId +
+                '}';
     }
 
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/AttributesImmediateOutputStrategy.java

@@ -35,4 +35,26 @@ public class AttributesImmediateOutputStrategy implements AttributesOutputStrate
     public OutputStrategyType getType() {
         return OutputStrategyType.IMMEDIATE;
     }
+
+    @Override
+    public boolean hasContextOnlyChanges(OutputStrategy other) {
+        if (!(other instanceof AttributesImmediateOutputStrategy otherStrategy)) {
+            return true;
+        }
+        boolean saveTimeSeriesUpdated = saveAttribute != otherStrategy.isSaveAttribute();
+        boolean sendWsUpdateUpdated = sendWsUpdate != otherStrategy.isSendWsUpdate();
+        boolean processCfsUpdated = processCfs != otherStrategy.isProcessCfs();
+        return saveTimeSeriesUpdated || sendWsUpdateUpdated || processCfsUpdated;
+    }
+
+    @Override
+    public boolean hasRefreshContextOnlyChanges(OutputStrategy other) {
+        if (!(other instanceof AttributesImmediateOutputStrategy otherStrategy)) {
+            return true;
+        }
+        boolean updateAttrOnValueChangedChanged = updateAttributesOnlyOnValueChange != otherStrategy.isUpdateAttributesOnlyOnValueChange();
+        boolean sendAttrUpdatedNotificationChanged = sendAttributesUpdatedNotification != otherStrategy.isSendAttributesUpdatedNotification();
+        return updateAttrOnValueChangedChanged || sendAttrUpdatedNotificationChanged;
+    }
+
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/AttributesRuleChainOutputStrategy.java

@@ -26,4 +26,15 @@ public class AttributesRuleChainOutputStrategy implements AttributesOutputStrate
     public OutputStrategyType getType() {
         return OutputStrategyType.RULE_CHAIN;
     }
+
+    @Override
+    public boolean hasContextOnlyChanges(OutputStrategy other) {
+        return !(other instanceof AttributesRuleChainOutputStrategy);
+    }
+
+    @Override
+    public boolean hasRefreshContextOnlyChanges(OutputStrategy other) {
+        return false;
+    }
+
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/Output.java

@@ -22,6 +22,8 @@ import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.thingsboard.server.common.data.AttributeScope;
 
+import java.util.Objects;
+
 @JsonTypeInfo(
         use = JsonTypeInfo.Id.NAME,
         include = JsonTypeInfo.As.PROPERTY,
@@ -50,4 +52,23 @@ public interface Output {
 
     void setDecimalsByDefault(Integer decimalsByDefault);
 
+    default boolean hasContextOnlyChanges(Output other) {
+        if (!getType().equals(other.getType())) {
+            return true;
+        }
+        if (!Objects.equals(getName(), other.getName())) {
+            return true;
+        }
+        if (getScope() != (other.getScope())) {
+            return true;
+        }
+        if (!Objects.equals(getDecimalsByDefault(), other.getDecimalsByDefault())) {
+            return true;
+        }
+        if (getStrategy().hasContextOnlyChanges(other.getStrategy())) {
+            return true;
+        }
+        return false;
+    }
+
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/OutputStrategy.java

@@ -22,4 +22,8 @@ public interface OutputStrategy {
     @JsonIgnore
     OutputStrategyType getType();
 
+    boolean hasContextOnlyChanges(OutputStrategy other);
+
+    boolean hasRefreshContextOnlyChanges(OutputStrategy other);
+
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/TimeSeriesImmediateOutputStrategy.java

@@ -35,4 +35,25 @@ public class TimeSeriesImmediateOutputStrategy implements TimeSeriesOutputStrate
     public OutputStrategyType getType() {
         return OutputStrategyType.IMMEDIATE;
     }
+
+    @Override
+    public boolean hasContextOnlyChanges(OutputStrategy other) {
+        if (!(other instanceof TimeSeriesImmediateOutputStrategy otherStrategy)) {
+            return true;
+        }
+        boolean saveTimeSeriesUpdated = saveTimeSeries != otherStrategy.isSaveTimeSeries();
+        boolean saveLatestUpdated = saveLatest != otherStrategy.isSaveLatest();
+        boolean sendWsUpdateUpdated = sendWsUpdate != otherStrategy.isSendWsUpdate();
+        boolean processCfsUpdated = processCfs != otherStrategy.isProcessCfs();
+        return saveTimeSeriesUpdated || saveLatestUpdated || sendWsUpdateUpdated || processCfsUpdated;
+    }
+
+    @Override
+    public boolean hasRefreshContextOnlyChanges(OutputStrategy other) {
+        if (!(other instanceof TimeSeriesImmediateOutputStrategy otherStrategy)) {
+            return true;
+        }
+        return ttl != otherStrategy.getTtl();
+    }
+
 }

common/data/src/main/java/org/thingsboard/server/common/data/cf/configuration/TimeSeriesRuleChainOutputStrategy.java

@@ -26,4 +26,15 @@ public class TimeSeriesRuleChainOutputStrategy implements TimeSeriesOutputStrate
     public OutputStrategyType getType() {
         return OutputStrategyType.RULE_CHAIN;
     }
+
+    @Override
+    public boolean hasContextOnlyChanges(OutputStrategy other) {
+        return !(other instanceof TimeSeriesRuleChainOutputStrategy);
+    }
+
+    @Override
+    public boolean hasRefreshContextOnlyChanges(OutputStrategy other) {
+        return false;
+    }
+
 }

common/data/src/test/java/org/thingsboard/server/common/data/cf/configuration/CalculatedFieldOutputTest.java

@@ -0,0 +1,202 @@
+/**
+ * Copyright © 2016-2025 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.common.data.cf.configuration;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.thingsboard.server.common.data.AttributeScope;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+@ExtendWith(MockitoExtension.class)
+public class CalculatedFieldOutputTest {
+
+    @Test
+    public void testHasContextOnlyChanges_whenTypeChanged_shouldReturnTrue() {
+        TimeSeriesOutput output = new TimeSeriesOutput();
+        AttributesOutput newOutput = new AttributesOutput();
+
+        assertThat(output.hasContextOnlyChanges(newOutput)).isTrue();
+    }
+
+    @Test
+    public void testHasContextOnlyChanges_whenNameChanged_shouldReturnTrue() {
+        TimeSeriesOutput output = new TimeSeriesOutput();
+        TimeSeriesOutput newOutput = new TimeSeriesOutput();
+        newOutput.setName("new");
+
+        assertThat(output.hasContextOnlyChanges(newOutput)).isTrue();
+    }
+
+    @Test
+    public void testHasContextOnlyChanges_whenScopeChanged_shouldReturnTrue() {
+        AttributesOutput output = new AttributesOutput();
+        output.setScope(AttributeScope.SHARED_SCOPE);
+        AttributesOutput newOutput = new AttributesOutput();
+        newOutput.setScope(AttributeScope.SERVER_SCOPE);
+
+        assertThat(output.hasContextOnlyChanges(newOutput)).isTrue();
+    }
+
+    @Test
+    public void testHasContextOnlyChanges_whenDecimalsByDefaultChanged_shouldReturnTrue() {
+        AttributesOutput output = new AttributesOutput();
+        AttributesOutput newOutput = new AttributesOutput();
+        newOutput.setDecimalsByDefault(2);
+
+        assertThat(output.hasContextOnlyChanges(newOutput)).isTrue();
+    }
+
+    @Test
+    public void testHasContextOnlyChanges_whenStrategyHasContextOnlyChanges_shouldReturnTrue() {
+        AttributesOutputStrategy outputStrategy = mock(AttributesRuleChainOutputStrategy.class);
+        given(outputStrategy.hasContextOnlyChanges(any())).willReturn(true);
+
+        AttributesOutput output = new AttributesOutput();
+        output.setStrategy(outputStrategy);
+        AttributesOutput newOutput = new AttributesOutput();
+
+        assertThat(output.hasContextOnlyChanges(newOutput)).isTrue();
+    }
+
+    @Test
+    public void testHasContextOnlyChanges_whenStrategyDoesNotHaveContextOnlyChanges_shouldReturnTrue() {
+        AttributesOutputStrategy outputStrategy = mock(AttributesRuleChainOutputStrategy.class);
+        given(outputStrategy.hasContextOnlyChanges(any())).willReturn(false);
+
+        AttributesOutput output = new AttributesOutput();
+        output.setStrategy(outputStrategy);
+        AttributesOutput newOutput = new AttributesOutput();
+
+        assertThat(output.hasContextOnlyChanges(newOutput)).isFalse();
+    }
+
+    /* <strategy>.hasContextOnlyChanges() tests*/
+
+    @Test
+    public void testAttributesImmediateOutputStrategyHasContextOnlyChanges_whenTypeChanged_shouldReturnTrue() {
+        AttributesImmediateOutputStrategy strategy = new AttributesImmediateOutputStrategy(true, true, false, true, true);
+        AttributesRuleChainOutputStrategy newStrategy = new AttributesRuleChainOutputStrategy();
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testAttributesImmediateOutputStrategyHasContextOnlyChanges_whenSaveAttributesChanged_shouldReturnTrue() {
+        AttributesImmediateOutputStrategy strategy = new AttributesImmediateOutputStrategy(true, true, false, true, true);
+        AttributesImmediateOutputStrategy newStrategy = new AttributesImmediateOutputStrategy(true, true, true, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testAttributesImmediateOutputStrategyHasContextOnlyChanges_whenSendWsUpdateChanged_shouldReturnTrue() {
+        AttributesImmediateOutputStrategy strategy = new AttributesImmediateOutputStrategy(true, true, true, false, true);
+        AttributesImmediateOutputStrategy newStrategy = new AttributesImmediateOutputStrategy(true, true, true, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testAttributesImmediateOutputStrategyHasContextOnlyChanges_whenProcessCfsChanged_shouldReturnTrue() {
+        AttributesImmediateOutputStrategy strategy = new AttributesImmediateOutputStrategy(true, true, true, false, false);
+        AttributesImmediateOutputStrategy newStrategy = new AttributesImmediateOutputStrategy(true, true, true, false, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testAttributesRuleChainOutputStrategyHasContextOnlyChanges_whenTypeChanged_shouldReturnTrue() {
+        AttributesRuleChainOutputStrategy strategy = new AttributesRuleChainOutputStrategy();
+        AttributesImmediateOutputStrategy newStrategy = new AttributesImmediateOutputStrategy(true, true, false, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testTimeSeriesImmediateOutputStrategyHasContextOnlyChanges_whenTypeChanged_shouldReturnTrue() {
+        TimeSeriesImmediateOutputStrategy strategy = new TimeSeriesImmediateOutputStrategy(0, false, true, true, true);
+        TimeSeriesRuleChainOutputStrategy newStrategy = new TimeSeriesRuleChainOutputStrategy();
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testTimeSeriesImmediateOutputStrategyHasContextOnlyChanges_whenSaveLatestChanged_shouldReturnTrue() {
+        TimeSeriesImmediateOutputStrategy strategy = new TimeSeriesImmediateOutputStrategy(0, false, false, true, true);
+        TimeSeriesImmediateOutputStrategy newStrategy = new TimeSeriesImmediateOutputStrategy(0, false, true, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testTimeSeriesImmediateOutputStrategyHasContextOnlyChanges_whenSendWsUpdateChanged_shouldReturnTrue() {
+        TimeSeriesImmediateOutputStrategy strategy = new TimeSeriesImmediateOutputStrategy(0, true, true, false, true);
+        TimeSeriesImmediateOutputStrategy newStrategy = new TimeSeriesImmediateOutputStrategy(0, true, true, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testTimeSeriesImmediateOutputStrategyHasContextOnlyChanges_whenProcessCfsChanged_shouldReturnTrue() {
+        TimeSeriesImmediateOutputStrategy strategy = new TimeSeriesImmediateOutputStrategy(0, true, true, true, false);
+        TimeSeriesImmediateOutputStrategy newStrategy = new TimeSeriesImmediateOutputStrategy(0, true, true, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testTimeSeriesRuleChainOutputStrategyHasContextOnlyChanges_whenProcessCfsChanged_shouldReturnTrue() {
+        TimeSeriesRuleChainOutputStrategy strategy = new TimeSeriesRuleChainOutputStrategy();
+        TimeSeriesImmediateOutputStrategy newStrategy = new TimeSeriesImmediateOutputStrategy(0, true, true, true, false);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    /* <strategy>.hasRefreshContextOnlyChanges() tests*/
+
+    @Test
+    public void testAttributesImmediateOutputStrategyHasRefreshContextOnlyChanges_whenUpdateAttrOnValueChangedChanged_shouldReturnTrue() {
+        AttributesImmediateOutputStrategy strategy = new AttributesImmediateOutputStrategy(true, false, true, false, true);
+        AttributesImmediateOutputStrategy newStrategy = new AttributesImmediateOutputStrategy(true, true, true, false, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isFalse();
+        assertThat(strategy.hasRefreshContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testAttributesImmediateOutputStrategyHasRefreshContextOnlyChanges_whenSendAttrUpdatedNotificationChanged_shouldReturnTrue() {
+        AttributesImmediateOutputStrategy strategy = new AttributesImmediateOutputStrategy(false, true, true, false, true);
+        AttributesImmediateOutputStrategy newStrategy = new AttributesImmediateOutputStrategy(true, true, true, false, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isFalse();
+        assertThat(strategy.hasRefreshContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+    @Test
+    public void testTimeSeriesImmediateOutputStrategyHasRefreshContextOnlyChanges_whenTtlChanged_shouldReturnTrue() {
+        TimeSeriesImmediateOutputStrategy strategy = new TimeSeriesImmediateOutputStrategy(0, true, true, true, true);
+        TimeSeriesImmediateOutputStrategy newStrategy = new TimeSeriesImmediateOutputStrategy(300, true, true, true, true);
+
+        assertThat(strategy.hasContextOnlyChanges(newStrategy)).isFalse();
+        assertThat(strategy.hasRefreshContextOnlyChanges(newStrategy)).isTrue();
+    }
+
+}