From 0d0ca90cf96cd63a2da79ee28e93110434a18734 Mon Sep 17 00:00:00 2001 From: thingsboard648 Date: Tue, 5 Mar 2024 10:38:19 +0200 Subject: [PATCH 1/4] added property to ignore delta in output messages if it is zero --- .../engine/metadata/CalculateDeltaNode.java | 27 +++++++++- .../CalculateDeltaNodeConfiguration.java | 3 +- .../metadata/CalculateDeltaNodeTest.java | 54 ++++++++++++++++++- 3 files changed, 80 insertions(+), 4 deletions(-) diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java index 609888db84..510d089372 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java @@ -32,6 +32,7 @@ import org.thingsboard.server.common.data.kv.TsKvEntry; import org.thingsboard.server.common.data.msg.TbMsgType; import org.thingsboard.server.common.data.msg.TbNodeConnectionType; import org.thingsboard.server.common.data.plugin.ComponentType; +import org.thingsboard.server.common.data.util.TbPair; import org.thingsboard.server.common.msg.TbMsg; import org.thingsboard.server.dao.timeseries.TimeseriesService; @@ -46,7 +47,9 @@ import static org.thingsboard.common.util.DonAsynchron.withCallback; @Slf4j @RuleNode(type = ComponentType.ENRICHMENT, - name = "calculate delta", relationTypes = {TbNodeConnectionType.SUCCESS, TbNodeConnectionType.FAILURE, TbNodeConnectionType.OTHER}, + name = "calculate delta", + version = 1, + relationTypes = {TbNodeConnectionType.SUCCESS, TbNodeConnectionType.FAILURE, TbNodeConnectionType.OTHER}, configClazz = CalculateDeltaNodeConfiguration.class, nodeDescription = "Calculates delta and amount of time passed between previous timeseries key reading " + "and current value for this key from the incoming message", @@ -96,6 +99,11 @@ public class CalculateDeltaNode implements TbNode { BigDecimal delta = BigDecimal.valueOf(previousData != null ? currentValue - previousData.value : 0.0); + if (config.isOnlyComputeTrueDeltas() && delta.doubleValue() == 0) { + ctx.tellSuccess(msg); + return; + } + if (config.isTellFailureIfDeltaIsNegative() && delta.doubleValue() < 0) { ctx.tellFailure(msg, new IllegalArgumentException("Delta value is negative!")); return; @@ -128,6 +136,23 @@ public class CalculateDeltaNode implements TbNode { } } + @Override + public TbPair upgrade(int fromVersion, JsonNode oldConfiguration) throws TbNodeException { + boolean hasChanges = false; + switch (fromVersion) { + case 0: + String onlyComputeTrueDeltas = "onlyComputeTrueDeltas"; + if (!oldConfiguration.has(onlyComputeTrueDeltas)) { + hasChanges = true; + ((ObjectNode) oldConfiguration).put(onlyComputeTrueDeltas, false); + } + break; + default: + break; + } + return new TbPair<>(hasChanges, oldConfiguration); + } + private ListenableFuture fetchLatestValueAsync(EntityId entityId) { return Futures.transform(timeseriesService.findLatest(ctx.getTenantId(), entityId, Collections.singletonList(config.getInputValueKey())), list -> extractValue(list.get(0)) diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java index 0c4e6de556..9f30aae22b 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java @@ -30,6 +30,7 @@ public class CalculateDeltaNodeConfiguration implements NodeConfiguration givenFromVersionAndConfig_whenUpgrade_thenVerifyHasChangesAndConfig() { + return Stream.of( + // default config for version 0 + Arguments.of(0, + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true}", + true, + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"onlyComputeTrueDeltas\":false}"), + // default config for version 1 with upgrade from version 0 + Arguments.of(1, + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"onlyComputeTrueDeltas\":false}", + false, + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"onlyComputeTrueDeltas\":false}") + ); + + } + + @Override + protected TbNode getTestNode() { + return node; + } } From 96a71ad8dc07ba4f08eebe878ea52be699532327 Mon Sep 17 00:00:00 2001 From: thingsboard648 Date: Tue, 5 Mar 2024 16:03:00 +0200 Subject: [PATCH 2/4] changed the check to exclude only 0 deltas from the message --- .../engine/metadata/CalculateDeltaNode.java | 14 +-- .../CalculateDeltaNodeConfiguration.java | 5 +- .../metadata/CalculateDeltaNodeTest.java | 90 ++++++++++++++++--- 3 files changed, 88 insertions(+), 21 deletions(-) diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java index 510d089372..ce3a318fe6 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java @@ -99,13 +99,13 @@ public class CalculateDeltaNode implements TbNode { BigDecimal delta = BigDecimal.valueOf(previousData != null ? currentValue - previousData.value : 0.0); - if (config.isOnlyComputeTrueDeltas() && delta.doubleValue() == 0) { - ctx.tellSuccess(msg); + if (config.isTellFailureIfDeltaIsNegative() && delta.doubleValue() < 0) { + ctx.tellFailure(msg, new IllegalArgumentException("Delta value is negative!")); return; } - if (config.isTellFailureIfDeltaIsNegative() && delta.doubleValue() < 0) { - ctx.tellFailure(msg, new IllegalArgumentException("Delta value is negative!")); + if (config.isExcludeZeroDeltasFromOutboundMessage() && delta.doubleValue() == 0) { + ctx.tellSuccess(msg); return; } @@ -141,10 +141,10 @@ public class CalculateDeltaNode implements TbNode { boolean hasChanges = false; switch (fromVersion) { case 0: - String onlyComputeTrueDeltas = "onlyComputeTrueDeltas"; - if (!oldConfiguration.has(onlyComputeTrueDeltas)) { + String excludeZeroDeltasFromOutboundMessage = "excludeZeroDeltasFromOutboundMessage"; + if (!oldConfiguration.has(excludeZeroDeltasFromOutboundMessage)) { hasChanges = true; - ((ObjectNode) oldConfiguration).put(onlyComputeTrueDeltas, false); + ((ObjectNode) oldConfiguration).put(excludeZeroDeltasFromOutboundMessage, false); } break; default: diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java index 9f30aae22b..82a2eb85b0 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java @@ -30,7 +30,7 @@ public class CalculateDeltaNodeConfiguration implements NodeConfiguration CalculateDeltaTestConfig() { + return Stream.of( + // delta = 0, tell failure if delta is negative is set to true and exclude zero deltas from outbound message is set to true so delta should filter out the message. + new CalculateDeltaTestConfig(true, true, 40, 40, (ctx, msg) -> { + verify(ctx).tellSuccess(eq(msg)); + verify(ctx).getDbCallbackExecutor(); + verifyNoMoreInteractions(ctx); + }), + // delta < 0, tell failure if delta is negative is set to true so it should throw exception. + new CalculateDeltaTestConfig(true, true, 40, 41, (ctx, msg) -> { + var errorCaptor = ArgumentCaptor.forClass(Throwable.class); + verify(ctx).tellFailure(eq(msg), errorCaptor.capture()); + verify(ctx).getDbCallbackExecutor(); + verifyNoMoreInteractions(ctx); + assertThat(errorCaptor.getValue()).isInstanceOf(IllegalArgumentException.class).hasMessage("Delta value is negative!"); + }), + // delta < 0, exclude zero deltas from outbound message is set to true so it should return message with delta if delta is negative is set to false. + new CalculateDeltaTestConfig(false, true, 40, 41, (ctx, msg) -> { + var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); + verify(ctx).tellSuccess(actualMsgCaptor.capture()); + verify(ctx).getDbCallbackExecutor(); + verifyNoMoreInteractions(ctx); + String expectedMsgData = "{\"temperature\":40.0,\"airPressure\":123,\"delta\":-1}"; + assertEquals(expectedMsgData, actualMsgCaptor.getValue().getData()); + }), + // delta = 0, tell failure if delta is negative is set to false and exclude zero deltas from outbound message is set to true so delta should filter out the message. + new CalculateDeltaTestConfig(false, true, 40, 40, (ctx, msg) -> { + verify(ctx).tellSuccess(eq(msg)); + verify(ctx).getDbCallbackExecutor(); + verifyNoMoreInteractions(ctx); + }), + // delta > 0, exclude zero deltas from outbound message is set to true so it should return message with delta. + new CalculateDeltaTestConfig(false, true, 40, 39, (ctx, msg) -> { + var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); + verify(ctx).tellSuccess(actualMsgCaptor.capture()); + verify(ctx).getDbCallbackExecutor(); + verifyNoMoreInteractions(ctx); + String expectedMsgData = "{\"temperature\":40.0,\"airPressure\":123,\"delta\":1}"; + assertEquals(expectedMsgData, actualMsgCaptor.getValue().getData()); + }), + // delta > 0, exclude zero deltas from outbound message is set to false so it should return message with delta. + new CalculateDeltaTestConfig(false, false, 40, 39, (ctx, msg) -> { + var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); + verify(ctx).tellSuccess(actualMsgCaptor.capture()); + verify(ctx).getDbCallbackExecutor(); + verifyNoMoreInteractions(ctx); + String expectedMsgData = "{\"temperature\":40.0,\"airPressure\":123,\"delta\":1}"; + assertEquals(expectedMsgData, actualMsgCaptor.getValue().getData()); + }) + ); + } + + @Data + @RequiredArgsConstructor + static class CalculateDeltaTestConfig { + private final boolean tellFailureIfDeltaIsNegative; + private final boolean computeOnlyTrueDeltas; + private final double currentValue; + private final double prevValue; + private final BiConsumer verificationMethod; } private void mockFindLatest(TsKvEntry tsKvEntry) { @@ -493,12 +559,12 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { Arguments.of(0, "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true}", true, - "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"onlyComputeTrueDeltas\":false}"), + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltasFromOutboundMessage\":false}"), // default config for version 1 with upgrade from version 0 Arguments.of(1, - "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"onlyComputeTrueDeltas\":false}", + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltasFromOutboundMessage\":false}", false, - "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"onlyComputeTrueDeltas\":false}") + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltasFromOutboundMessage\":false}") ); } From c18cef5eda3e5caf8857ffa32978acaa0119857a Mon Sep 17 00:00:00 2001 From: IrynaMatveieva Date: Tue, 5 Mar 2024 16:37:53 +0200 Subject: [PATCH 3/4] changed variable names --- .../engine/metadata/CalculateDeltaNode.java | 8 ++++---- .../CalculateDeltaNodeConfiguration.java | 4 ++-- .../metadata/CalculateDeltaNodeTest.java | 18 +++++++++--------- 3 files changed, 15 insertions(+), 15 deletions(-) diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java index ce3a318fe6..7141d66f42 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNode.java @@ -104,7 +104,7 @@ public class CalculateDeltaNode implements TbNode { return; } - if (config.isExcludeZeroDeltasFromOutboundMessage() && delta.doubleValue() == 0) { + if (config.isExcludeZeroDeltas() && delta.doubleValue() == 0) { ctx.tellSuccess(msg); return; } @@ -141,10 +141,10 @@ public class CalculateDeltaNode implements TbNode { boolean hasChanges = false; switch (fromVersion) { case 0: - String excludeZeroDeltasFromOutboundMessage = "excludeZeroDeltasFromOutboundMessage"; - if (!oldConfiguration.has(excludeZeroDeltasFromOutboundMessage)) { + String excludeZeroDeltas = "excludeZeroDeltas"; + if (!oldConfiguration.has(excludeZeroDeltas)) { hasChanges = true; - ((ObjectNode) oldConfiguration).put(excludeZeroDeltasFromOutboundMessage, false); + ((ObjectNode) oldConfiguration).put(excludeZeroDeltas, false); } break; default: diff --git a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java index 82a2eb85b0..0ae558718b 100644 --- a/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java +++ b/rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeConfiguration.java @@ -30,7 +30,7 @@ public class CalculateDeltaNodeConfiguration implements NodeConfiguration CalculateDeltaTestConfig() { return Stream.of( - // delta = 0, tell failure if delta is negative is set to true and exclude zero deltas from outbound message is set to true so delta should filter out the message. + // delta = 0, tell failure if delta is negative is set to true and exclude zero deltas is set to true so delta should filter out the message. new CalculateDeltaTestConfig(true, true, 40, 40, (ctx, msg) -> { verify(ctx).tellSuccess(eq(msg)); verify(ctx).getDbCallbackExecutor(); @@ -474,7 +474,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { verifyNoMoreInteractions(ctx); assertThat(errorCaptor.getValue()).isInstanceOf(IllegalArgumentException.class).hasMessage("Delta value is negative!"); }), - // delta < 0, exclude zero deltas from outbound message is set to true so it should return message with delta if delta is negative is set to false. + // delta < 0, exclude zero deltas is set to true so it should return message with delta if delta is negative is set to false. new CalculateDeltaTestConfig(false, true, 40, 41, (ctx, msg) -> { var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); verify(ctx).tellSuccess(actualMsgCaptor.capture()); @@ -483,13 +483,13 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { String expectedMsgData = "{\"temperature\":40.0,\"airPressure\":123,\"delta\":-1}"; assertEquals(expectedMsgData, actualMsgCaptor.getValue().getData()); }), - // delta = 0, tell failure if delta is negative is set to false and exclude zero deltas from outbound message is set to true so delta should filter out the message. + // delta = 0, tell failure if delta is negative is set to false and exclude zero deltas is set to true so delta should filter out the message. new CalculateDeltaTestConfig(false, true, 40, 40, (ctx, msg) -> { verify(ctx).tellSuccess(eq(msg)); verify(ctx).getDbCallbackExecutor(); verifyNoMoreInteractions(ctx); }), - // delta > 0, exclude zero deltas from outbound message is set to true so it should return message with delta. + // delta > 0, exclude zero deltas is set to true so it should return message with delta. new CalculateDeltaTestConfig(false, true, 40, 39, (ctx, msg) -> { var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); verify(ctx).tellSuccess(actualMsgCaptor.capture()); @@ -498,7 +498,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { String expectedMsgData = "{\"temperature\":40.0,\"airPressure\":123,\"delta\":1}"; assertEquals(expectedMsgData, actualMsgCaptor.getValue().getData()); }), - // delta > 0, exclude zero deltas from outbound message is set to false so it should return message with delta. + // delta > 0, exclude zero deltas is set to false so it should return message with delta. new CalculateDeltaTestConfig(false, false, 40, 39, (ctx, msg) -> { var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); verify(ctx).tellSuccess(actualMsgCaptor.capture()); @@ -559,12 +559,12 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { Arguments.of(0, "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true}", true, - "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltasFromOutboundMessage\":false}"), + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltas\":false}"), // default config for version 1 with upgrade from version 0 Arguments.of(1, - "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltasFromOutboundMessage\":false}", + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltas\":false}", false, - "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltasFromOutboundMessage\":false}") + "{\"inputValueKey\":\"pulseCounter\",\"outputValueKey\":\"delta\",\"useCache\":true,\"addPeriodBetweenMsgs\":false, \"periodValueKey\":\"periodInMs\", \"round\":null,\"tellFailureIfDeltaIsNegative\":true, \"excludeZeroDeltas\":false}") ); } From 7d4d7f97aa933299797f6f1355ba5cb64214a674 Mon Sep 17 00:00:00 2001 From: IrynaMatveieva Date: Wed, 6 Mar 2024 10:21:00 +0200 Subject: [PATCH 4/4] restricted access modifier for CalculateDeltaTestConfig to private --- .../metadata/CalculateDeltaNodeTest.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeTest.java b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeTest.java index 404ee49287..74269b9be6 100644 --- a/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeTest.java +++ b/rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/metadata/CalculateDeltaNodeTest.java @@ -440,7 +440,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { public void givenCalculateDeltaConfig_whenOnMsg_thenVerify(CalculateDeltaTestConfig testConfig) throws TbNodeException { // GIVEN config.setTellFailureIfDeltaIsNegative(testConfig.isTellFailureIfDeltaIsNegative()); - config.setExcludeZeroDeltas(testConfig.isComputeOnlyTrueDeltas()); + config.setExcludeZeroDeltas(testConfig.isExcludeZeroDeltas()); config.setInputValueKey("temperature"); nodeConfiguration = new TbNodeConfiguration(JacksonUtil.valueToTree(config)); node.init(ctxMock, nodeConfiguration); @@ -458,7 +458,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { testConfig.getVerificationMethod().accept(ctxMock, msg); } - static Stream CalculateDeltaTestConfig() { + private static Stream CalculateDeltaTestConfig() { return Stream.of( // delta = 0, tell failure if delta is negative is set to true and exclude zero deltas is set to true so delta should filter out the message. new CalculateDeltaTestConfig(true, true, 40, 40, (ctx, msg) -> { @@ -467,7 +467,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { verifyNoMoreInteractions(ctx); }), // delta < 0, tell failure if delta is negative is set to true so it should throw exception. - new CalculateDeltaTestConfig(true, true, 40, 41, (ctx, msg) -> { + new CalculateDeltaTestConfig(true, true, 41, 40, (ctx, msg) -> { var errorCaptor = ArgumentCaptor.forClass(Throwable.class); verify(ctx).tellFailure(eq(msg), errorCaptor.capture()); verify(ctx).getDbCallbackExecutor(); @@ -475,7 +475,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { assertThat(errorCaptor.getValue()).isInstanceOf(IllegalArgumentException.class).hasMessage("Delta value is negative!"); }), // delta < 0, exclude zero deltas is set to true so it should return message with delta if delta is negative is set to false. - new CalculateDeltaTestConfig(false, true, 40, 41, (ctx, msg) -> { + new CalculateDeltaTestConfig(false, true, 41, 40, (ctx, msg) -> { var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); verify(ctx).tellSuccess(actualMsgCaptor.capture()); verify(ctx).getDbCallbackExecutor(); @@ -490,7 +490,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { verifyNoMoreInteractions(ctx); }), // delta > 0, exclude zero deltas is set to true so it should return message with delta. - new CalculateDeltaTestConfig(false, true, 40, 39, (ctx, msg) -> { + new CalculateDeltaTestConfig(false, true, 39, 40, (ctx, msg) -> { var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); verify(ctx).tellSuccess(actualMsgCaptor.capture()); verify(ctx).getDbCallbackExecutor(); @@ -499,7 +499,7 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { assertEquals(expectedMsgData, actualMsgCaptor.getValue().getData()); }), // delta > 0, exclude zero deltas is set to false so it should return message with delta. - new CalculateDeltaTestConfig(false, false, 40, 39, (ctx, msg) -> { + new CalculateDeltaTestConfig(false, false, 39, 40, (ctx, msg) -> { var actualMsgCaptor = ArgumentCaptor.forClass(TbMsg.class); verify(ctx).tellSuccess(actualMsgCaptor.capture()); verify(ctx).getDbCallbackExecutor(); @@ -512,11 +512,11 @@ public class CalculateDeltaNodeTest extends AbstractRuleNodeUpgradeTest { @Data @RequiredArgsConstructor - static class CalculateDeltaTestConfig { + private static class CalculateDeltaTestConfig { private final boolean tellFailureIfDeltaIsNegative; - private final boolean computeOnlyTrueDeltas; - private final double currentValue; + private final boolean excludeZeroDeltas; private final double prevValue; + private final double currentValue; private final BiConsumer verificationMethod; }