dendi-wang/thingsboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into improvement/mqtt-reason-codes

Browse Source
This commit is contained in:
imbeacon 2024-05-10 14:55:11 +03:00
commit 224a22d093
14 changed files with 110 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
application/src/main/java/org/thingsboard/server/service/entitiy/AbstractTbEntityService.java
View File

@ -22,6 +22,7 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy; import org.springframework.context.annotation.Lazy;
import org.springframework.core.env.Environment;
import org.thingsboard.server.cluster.TbClusterService; import org.thingsboard.server.cluster.TbClusterService;
import org.thingsboard.server.common.data.EntityType; import org.thingsboard.server.common.data.EntityType;
import org.thingsboard.server.common.data.User; import org.thingsboard.server.common.data.User;
@ -39,11 +40,15 @@ import org.thingsboard.server.service.telemetry.AlarmSubscriptionService;
import java.util.List; import java.util.List;
import java.util.Optional; import java.util.Optional;
import java.util.Set;
import java.util.UUID; import java.util.UUID;
@Slf4j @Slf4j
public abstract class AbstractTbEntityService { public abstract class AbstractTbEntityService {
@Autowired
private Environment env;
@Value("${server.log_controller_error_stack_trace}") @Value("${server.log_controller_error_stack_trace}")
@Getter @Getter
private boolean logControllerErrorStackTrace; private boolean logControllerErrorStackTrace;
@ -67,6 +72,10 @@ public abstract class AbstractTbEntityService {
@Lazy @Lazy
private EntitiesVersionControlService vcService; private EntitiesVersionControlService vcService;
protected boolean isTestProfile() {
return Set.of(this.env.getActiveProfiles()).contains("test");
}
protected <T> T checkNotNull(T reference) throws ThingsboardException { protected <T> T checkNotNull(T reference) throws ThingsboardException {
return checkNotNull(reference, "Requested item wasn't found!"); return checkNotNull(reference, "Requested item wasn't found!");
} }

3
application/src/main/java/org/thingsboard/server/service/entitiy/tenant/DefaultTbTenantService.java
View File

@ -17,6 +17,7 @@ package org.thingsboard.server.service.entitiy.tenant;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.beans.factory.annotation.Value;
import org.thingsboard.server.common.data.Tenant; import org.thingsboard.server.common.data.Tenant;
import org.thingsboard.server.common.data.TenantProfile; import org.thingsboard.server.common.data.TenantProfile;
import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.id.TenantId;
@ -52,7 +53,9 @@ public class DefaultTbTenantService extends AbstractTbEntityService implements T
Tenant savedTenant = tenantService.saveTenant(tenant, tenantId -> { Tenant savedTenant = tenantService.saveTenant(tenant, tenantId -> {
installScripts.createDefaultRuleChains(tenantId); installScripts.createDefaultRuleChains(tenantId);
installScripts.createDefaultEdgeRuleChains(tenantId); installScripts.createDefaultEdgeRuleChains(tenantId);
if (!isTestProfile()) {
installScripts.createDefaultTenantDashboards(tenantId, null); installScripts.createDefaultTenantDashboards(tenantId, null);
}
}); });
tenantProfileCache.evict(savedTenant.getId()); tenantProfileCache.evict(savedTenant.getId());

3
application/src/main/java/org/thingsboard/server/service/install/InstallScripts.java
View File

@ -317,7 +317,8 @@ public class InstallScripts {
@SneakyThrows @SneakyThrows
public void loadSystemImages() { public void loadSystemImages() {
log.info("Loading system images..."); log.info("Loading system images...");
Stream<Path> dashboardsFiles = Files.list(Paths.get(getDataDir(), JSON_DIR, DEMO_DIR, DASHBOARDS_DIR)); Stream<Path> dashboardsFiles = Stream.concat(Files.list(Paths.get(getDataDir(), JSON_DIR, DEMO_DIR, DASHBOARDS_DIR)),
Files.list(Paths.get(getDataDir(), JSON_DIR, TENANT_DIR, DASHBOARDS_DIR)));
try (dashboardsFiles) { try (dashboardsFiles) {
dashboardsFiles.forEach(file -> { dashboardsFiles.forEach(file -> {
try { try {

3
application/src/main/java/org/thingsboard/server/service/security/model/token/JwtTokenFactory.java
View File

@ -210,11 +210,12 @@ public class JwtTokenFactory {
ZonedDateTime currentTime = ZonedDateTime.now(); ZonedDateTime currentTime = ZonedDateTime.now();
claimsBuilder.expiration(Date.from(currentTime.plusSeconds(expirationTime).toInstant()));
return Jwts.builder() return Jwts.builder()
.claims(claimsBuilder.build()) .claims(claimsBuilder.build())
.issuer(jwtSettingsService.getJwtSettings().getTokenIssuer()) .issuer(jwtSettingsService.getJwtSettings().getTokenIssuer())
.issuedAt(Date.from(currentTime.toInstant())) .issuedAt(Date.from(currentTime.toInstant()))
.expiration(Date.from(currentTime.plusSeconds(expirationTime).toInstant()))
.signWith(getSecretKey(false), Jwts.SIG.HS512); .signWith(getSecretKey(false), Jwts.SIG.HS512);
} }

2
application/src/test/java/org/thingsboard/server/controller/HomePageApiTest.java
View File

@ -92,7 +92,7 @@ public class HomePageApiTest extends AbstractControllerTest {
@MockBean @MockBean
private SmsService smsService; private SmsService smsService;
private static final int DEFAULT_DASHBOARDS_COUNT = 1; private static final int DEFAULT_DASHBOARDS_COUNT = 0;
//For system administrator //For system administrator
@Test @Test

16
application/src/test/java/org/thingsboard/server/queue/discovery/HashPartitionServiceTest.java
View File

@ -20,12 +20,12 @@ import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils; import org.apache.commons.collections4.ListUtils;
import org.apache.commons.lang3.RandomStringUtils; import org.apache.commons.lang3.RandomStringUtils;
import org.junit.Assert; import org.junit.jupiter.api.Assertions;
import org.junit.Before; import org.junit.jupiter.api.Test;
import org.junit.Test; import org.junit.jupiter.api.BeforeEach;
import org.junit.runner.RunWith;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.context.ApplicationEventPublisher; import org.springframework.context.ApplicationEventPublisher;
import org.springframework.test.util.ReflectionTestUtils; import org.springframework.test.util.ReflectionTestUtils;
import org.thingsboard.server.common.data.DataConstants; import org.thingsboard.server.common.data.DataConstants;
@ -67,7 +67,7 @@ import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@Slf4j @Slf4j
@RunWith(MockitoJUnitRunner.class) @MockitoSettings(strictness = Strictness.LENIENT)
public class HashPartitionServiceTest { public class HashPartitionServiceTest {
public static final int ITERATIONS = 1000000; public static final int ITERATIONS = 1000000;
@ -82,7 +82,7 @@ public class HashPartitionServiceTest {
private String hashFunctionName = "murmur3_128"; private String hashFunctionName = "murmur3_128";
@Before @BeforeEach
public void setup() throws Exception { public void setup() throws Exception {
serviceInfoProvider = mock(TbServiceInfoProvider.class); serviceInfoProvider = mock(TbServiceInfoProvider.class);
applicationEventPublisher = mock(ApplicationEventPublisher.class); applicationEventPublisher = mock(ApplicationEventPublisher.class);
@ -173,7 +173,7 @@ public class HashPartitionServiceTest {
for (Map.Entry<T, Integer> entry : data) { for (Map.Entry<T, Integer> entry : data) {
System.out.println(entry.getKey() + ": " + entry.getValue()); System.out.println(entry.getKey() + ": " + entry.getValue());
} }
Assert.assertTrue(diffPercent < maxDiffPercent); Assertions.assertTrue(diffPercent < maxDiffPercent);
} }
@Test @Test

36
application/src/test/java/org/thingsboard/server/service/apiusage/DefaultTbApiUsageStateServiceTest.java
View File

@ -15,24 +15,16 @@
*/ */
package org.thingsboard.server.service.apiusage; package org.thingsboard.server.service.apiusage;
import org.junit.Before; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks; import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.Spy; import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoExtension;
import org.thingsboard.rule.engine.api.MailService;
import org.thingsboard.server.cluster.TbClusterService;
import org.thingsboard.server.common.data.ApiUsageState; import org.thingsboard.server.common.data.ApiUsageState;
import org.thingsboard.server.common.data.id.TenantId; import org.thingsboard.server.common.data.id.TenantId;
import org.thingsboard.server.dao.tenant.TbTenantProfileCache;
import org.thingsboard.server.dao.tenant.TenantService;
import org.thingsboard.server.dao.timeseries.TimeseriesService;
import org.thingsboard.server.dao.usagerecord.ApiUsageStateService;
import org.thingsboard.server.queue.discovery.PartitionService;
import org.thingsboard.server.service.executors.DbCallbackExecutorService;
import java.util.UUID; import java.util.UUID;
@ -40,27 +32,11 @@ import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.never; import static org.mockito.Mockito.never;
@RunWith(MockitoJUnitRunner.class) @ExtendWith(MockitoExtension.class)
public class DefaultTbApiUsageStateServiceTest { public class DefaultTbApiUsageStateServiceTest {
@Mock
TenantService tenantService;
@Mock
TimeseriesService tsService;
@Mock
TbClusterService clusterService;
@Mock
PartitionService partitionService;
@Mock @Mock
TenantApiUsageState tenantUsageStateMock; TenantApiUsageState tenantUsageStateMock;
@Mock
ApiUsageStateService apiUsageStateService;
@Mock
TbTenantProfileCache tenantProfileCache;
@Mock
MailService mailService;
@Mock
DbCallbackExecutorService dbExecutor;
TenantId tenantId = TenantId.fromUUID(UUID.fromString("00797a3b-7aeb-4b5b-b57a-c2a810d0f112")); TenantId tenantId = TenantId.fromUUID(UUID.fromString("00797a3b-7aeb-4b5b-b57a-c2a810d0f112"));
@ -68,7 +44,7 @@ public class DefaultTbApiUsageStateServiceTest {
@InjectMocks @InjectMocks
DefaultTbApiUsageStateService service; DefaultTbApiUsageStateService service;
@Before @BeforeEach
public void setUp() { public void setUp() {
} }

74
application/src/test/java/org/thingsboard/server/service/edge/rpc/constructor/RuleChainMsgConstructorTest.java
View File

@ -17,11 +17,11 @@ package org.thingsboard.server.service.edge.rpc.constructor;
import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.JsonNode;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.junit.Assert; import org.junit.jupiter.api.Assertions;
import org.junit.Before; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoExtension;
import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.common.util.JacksonUtil;
import org.thingsboard.server.common.data.id.RuleChainId; import org.thingsboard.server.common.data.id.RuleChainId;
import org.thingsboard.server.common.data.id.RuleNodeId; import org.thingsboard.server.common.data.id.RuleNodeId;
@ -44,7 +44,7 @@ import java.util.Optional;
import java.util.UUID; import java.util.UUID;
@Slf4j @Slf4j
@RunWith(MockitoJUnitRunner.class) @ExtendWith(MockitoExtension.class)
public class RuleChainMsgConstructorTest { public class RuleChainMsgConstructorTest {
private static final String RPC_CONNECTION_TYPE = "RPC"; private static final String RPC_CONNECTION_TYPE = "RPC";
@ -53,7 +53,7 @@ public class RuleChainMsgConstructorTest {
private TenantId tenantId; private TenantId tenantId;
@Before @BeforeEach
public void setup() { public void setup() {
ruleChainMsgConstructorV1 = new RuleChainMsgConstructorV1(); ruleChainMsgConstructorV1 = new RuleChainMsgConstructorV1();
tenantId = new TenantId(UUID.randomUUID()); tenantId = new TenantId(UUID.randomUUID());
@ -98,10 +98,10 @@ public class RuleChainMsgConstructorTest {
} }
private void assetV_3_3_3_and_V_3_4_0(RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg) { private void assetV_3_3_3_and_V_3_4_0(RuleChainMetadataUpdateMsg ruleChainMetadataUpdateMsg) {
Assert.assertEquals("First rule node index incorrect!", 3, ruleChainMetadataUpdateMsg.getFirstNodeIndex()); Assertions.assertEquals(3, ruleChainMetadataUpdateMsg.getFirstNodeIndex(), "First rule node index incorrect!");
Assert.assertEquals("Nodes count incorrect!", 12, ruleChainMetadataUpdateMsg.getNodesCount()); Assertions.assertEquals(12, ruleChainMetadataUpdateMsg.getNodesCount(), "Nodes count incorrect!");
Assert.assertEquals("Connections count incorrect!", 13, ruleChainMetadataUpdateMsg.getConnectionsCount()); Assertions.assertEquals(13, ruleChainMetadataUpdateMsg.getConnectionsCount(), "Connections count incorrect!");
Assert.assertEquals("Rule chain connections count incorrect!", 0, ruleChainMetadataUpdateMsg.getRuleChainConnectionsCount()); Assertions.assertEquals(0, ruleChainMetadataUpdateMsg.getRuleChainConnectionsCount(), "Rule chain connections count incorrect!");
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 6, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(0)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 6, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(0));
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 10, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(1)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 10, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(1));
@ -129,10 +129,10 @@ public class RuleChainMsgConstructorTest {
ruleChainMetaData, ruleChainMetaData,
EdgeVersion.V_3_3_0); EdgeVersion.V_3_3_0);
Assert.assertEquals("First rule node index incorrect!", 2, ruleChainMetadataUpdateMsg.getFirstNodeIndex()); Assertions.assertEquals(2, ruleChainMetadataUpdateMsg.getFirstNodeIndex(),"First rule node index incorrect!");
Assert.assertEquals("Nodes count incorrect!", 10, ruleChainMetadataUpdateMsg.getNodesCount()); Assertions.assertEquals(10, ruleChainMetadataUpdateMsg.getNodesCount(), "Nodes count incorrect!");
Assert.assertEquals("Connections count incorrect!", 10, ruleChainMetadataUpdateMsg.getConnectionsCount()); Assertions.assertEquals(10, ruleChainMetadataUpdateMsg.getConnectionsCount(),"Connections count incorrect!");
Assert.assertEquals("Rule chain connections count incorrect!", 1, ruleChainMetadataUpdateMsg.getRuleChainConnectionsCount()); Assertions.assertEquals(1, ruleChainMetadataUpdateMsg.getRuleChainConnectionsCount(), "Rule chain connections count incorrect!");
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(2, 5, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(0)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(2, 5, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(0));
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 9, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(1)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 9, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(1));
@ -146,13 +146,12 @@ public class RuleChainMsgConstructorTest {
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(6, 9, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(9)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(6, 9, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(9));
RuleChainConnectionInfoProto ruleChainConnection = ruleChainMetadataUpdateMsg.getRuleChainConnections(0); RuleChainConnectionInfoProto ruleChainConnection = ruleChainMetadataUpdateMsg.getRuleChainConnections(0);
Assert.assertEquals("From index incorrect!", 2, ruleChainConnection.getFromIndex()); Assertions.assertEquals(2, ruleChainConnection.getFromIndex(), "From index incorrect!");
Assert.assertEquals("Type index incorrect!", TbNodeConnectionType.SUCCESS, ruleChainConnection.getType()); Assertions.assertEquals(TbNodeConnectionType.SUCCESS, ruleChainConnection.getType(), "Type index incorrect!");
Assert.assertEquals("Additional info incorrect!", Assertions.assertEquals("{\"description\":\"\",\"layoutX\":477,\"layoutY\":560,\"ruleChainNodeId\":\"rule-chain-node-UNDEFINED\"}",
"{\"description\":\"\",\"layoutX\":477,\"layoutY\":560,\"ruleChainNodeId\":\"rule-chain-node-UNDEFINED\"}", ruleChainConnection.getAdditionalInfo(),"Additional info incorrect!");
ruleChainConnection.getAdditionalInfo()); Assertions.assertTrue(ruleChainConnection.getTargetRuleChainIdMSB() != 0,"Target rule chain id MSB incorrect!");
Assert.assertTrue("Target rule chain id MSB incorrect!", ruleChainConnection.getTargetRuleChainIdMSB() != 0); Assertions.assertTrue(ruleChainConnection.getTargetRuleChainIdLSB() != 0,"Target rule chain id LSB incorrect!");
Assert.assertTrue("Target rule chain id LSB incorrect!", ruleChainConnection.getTargetRuleChainIdLSB() != 0);
assertCheckpointRuleNodeConfiguration( assertCheckpointRuleNodeConfiguration(
ruleChainMetadataUpdateMsg.getNodesList(), ruleChainMetadataUpdateMsg.getNodesList(),
@ -171,10 +170,10 @@ public class RuleChainMsgConstructorTest {
ruleChainMetaData1, ruleChainMetaData1,
EdgeVersion.V_3_3_0); EdgeVersion.V_3_3_0);
Assert.assertEquals("First rule node index incorrect!", 7, ruleChainMetadataUpdateMsg.getFirstNodeIndex()); Assertions.assertEquals(7, ruleChainMetadataUpdateMsg.getFirstNodeIndex(), "First rule node index incorrect!");
Assert.assertEquals("Nodes count incorrect!", 10, ruleChainMetadataUpdateMsg.getNodesCount()); Assertions.assertEquals(10, ruleChainMetadataUpdateMsg.getNodesCount(),"Nodes count incorrect!");
Assert.assertEquals("Connections count incorrect!", 10, ruleChainMetadataUpdateMsg.getConnectionsCount()); Assertions.assertEquals(10, ruleChainMetadataUpdateMsg.getConnectionsCount(),"Connections count incorrect!");
Assert.assertEquals("Rule chain connections count incorrect!", 1, ruleChainMetadataUpdateMsg.getRuleChainConnectionsCount()); Assertions.assertEquals(1, ruleChainMetadataUpdateMsg.getRuleChainConnectionsCount(),"Rule chain connections count incorrect!");
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 0, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(0)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(3, 0, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(0));
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(4, 0, TbMsgType.ATTRIBUTES_UPDATED.getRuleNodeConnection()), ruleChainMetadataUpdateMsg.getConnections(1)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(4, 0, TbMsgType.ATTRIBUTES_UPDATED.getRuleNodeConnection()), ruleChainMetadataUpdateMsg.getConnections(1));
@ -188,13 +187,12 @@ public class RuleChainMsgConstructorTest {
compareNodeConnectionInfoAndProto(createNodeConnectionInfo(7, 4, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(9)); compareNodeConnectionInfoAndProto(createNodeConnectionInfo(7, 4, TbNodeConnectionType.SUCCESS), ruleChainMetadataUpdateMsg.getConnections(9));
RuleChainConnectionInfoProto ruleChainConnection = ruleChainMetadataUpdateMsg.getRuleChainConnections(0); RuleChainConnectionInfoProto ruleChainConnection = ruleChainMetadataUpdateMsg.getRuleChainConnections(0);
Assert.assertEquals("From index incorrect!", 7, ruleChainConnection.getFromIndex()); Assertions.assertEquals(7, ruleChainConnection.getFromIndex(),"From index incorrect!");
Assert.assertEquals("Type index incorrect!", TbNodeConnectionType.SUCCESS, ruleChainConnection.getType()); Assertions.assertEquals(TbNodeConnectionType.SUCCESS, ruleChainConnection.getType(), "Type index incorrect!");
Assert.assertEquals("Additional info incorrect!", Assertions.assertEquals( "{\"description\":\"\",\"layoutX\":477,\"layoutY\":560,\"ruleChainNodeId\":\"rule-chain-node-UNDEFINED\"}",
"{\"description\":\"\",\"layoutX\":477,\"layoutY\":560,\"ruleChainNodeId\":\"rule-chain-node-UNDEFINED\"}", ruleChainConnection.getAdditionalInfo(), "Additional info incorrect!");
ruleChainConnection.getAdditionalInfo()); Assertions.assertTrue(ruleChainConnection.getTargetRuleChainIdMSB() != 0, "Target rule chain id MSB incorrect!");
Assert.assertTrue("Target rule chain id MSB incorrect!", ruleChainConnection.getTargetRuleChainIdMSB() != 0); Assertions.assertTrue(ruleChainConnection.getTargetRuleChainIdLSB() != 0, "Target rule chain id LSB incorrect!");
Assert.assertTrue("Target rule chain id LSB incorrect!", ruleChainConnection.getTargetRuleChainIdLSB() != 0);
assertCheckpointRuleNodeConfiguration( assertCheckpointRuleNodeConfiguration(
ruleChainMetadataUpdateMsg.getNodesList(), ruleChainMetadataUpdateMsg.getNodesList(),
@ -206,15 +204,15 @@ public class RuleChainMsgConstructorTest {
Optional<RuleNodeProto> checkpointRuleNodeOpt = nodesList.stream() Optional<RuleNodeProto> checkpointRuleNodeOpt = nodesList.stream()
.filter(rn -> "org.thingsboard.rule.engine.flow.TbCheckpointNode".equals(rn.getType())) .filter(rn -> "org.thingsboard.rule.engine.flow.TbCheckpointNode".equals(rn.getType()))
.findFirst(); .findFirst();
Assert.assertTrue(checkpointRuleNodeOpt.isPresent()); Assertions.assertTrue(checkpointRuleNodeOpt.isPresent());
RuleNodeProto checkpointRuleNode = checkpointRuleNodeOpt.get(); RuleNodeProto checkpointRuleNode = checkpointRuleNodeOpt.get();
Assert.assertEquals(expectedConfiguration, checkpointRuleNode.getConfiguration()); Assertions.assertEquals(expectedConfiguration, checkpointRuleNode.getConfiguration());
} }
private void compareNodeConnectionInfoAndProto(NodeConnectionInfo expected, org.thingsboard.server.gen.edge.v1.NodeConnectionInfoProto actual) { private void compareNodeConnectionInfoAndProto(NodeConnectionInfo expected, org.thingsboard.server.gen.edge.v1.NodeConnectionInfoProto actual) {
Assert.assertEquals(expected.getFromIndex(), actual.getFromIndex()); Assertions.assertEquals(expected.getFromIndex(), actual.getFromIndex());
Assert.assertEquals(expected.getToIndex(), actual.getToIndex()); Assertions.assertEquals(expected.getToIndex(), actual.getToIndex());
Assert.assertEquals(expected.getType(), actual.getType()); Assertions.assertEquals(expected.getType(), actual.getType());
} }
private RuleChainMetaData createRuleChainMetaData(RuleChainId ruleChainId, Integer firstNodeIndex, List<RuleNode> nodes, List<NodeConnectionInfo> connections) { private RuleChainMetaData createRuleChainMetaData(RuleChainId ruleChainId, Integer firstNodeIndex, List<RuleNode> nodes, List<NodeConnectionInfo> connections) {

19
application/src/test/java/org/thingsboard/server/service/limits/RateLimitServiceTest.java
View File

@ -15,11 +15,12 @@
*/ */
package org.thingsboard.server.service.limits; package org.thingsboard.server.service.limits;
import org.junit.Before; import org.junit.jupiter.api.Assertions;
import org.junit.Test; import org.junit.jupiter.api.BeforeEach;
import org.junit.runner.RunWith; import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoExtension;
import org.thingsboard.server.cache.limits.DefaultRateLimitService; import org.thingsboard.server.cache.limits.DefaultRateLimitService;
import org.thingsboard.server.cache.limits.RateLimitService; import org.thingsboard.server.cache.limits.RateLimitService;
import org.thingsboard.server.common.data.TenantProfile; import org.thingsboard.server.common.data.TenantProfile;
@ -35,21 +36,19 @@ import org.thingsboard.server.dao.tenant.DefaultTbTenantProfileCache;
import java.util.List; import java.util.List;
import java.util.UUID; import java.util.UUID;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset; import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class) @ExtendWith(MockitoExtension.class)
public class RateLimitServiceTest { public class RateLimitServiceTest {
private RateLimitService rateLimitService; private RateLimitService rateLimitService;
private DefaultTbTenantProfileCache tenantProfileCache; private DefaultTbTenantProfileCache tenantProfileCache;
private TenantId tenantId; private TenantId tenantId;
@Before @BeforeEach
public void beforeEach() { public void beforeEach() {
tenantProfileCache = Mockito.mock(DefaultTbTenantProfileCache.class); tenantProfileCache = Mockito.mock(DefaultTbTenantProfileCache.class);
rateLimitService = new DefaultRateLimitService(tenantProfileCache, mock(NotificationRuleProcessor.class), 60, 100); rateLimitService = new DefaultRateLimitService(tenantProfileCache, mock(NotificationRuleProcessor.class), 60, 100);
@ -102,10 +101,10 @@ public class RateLimitServiceTest {
private void testRateLimits(LimitedApi limitedApi, int max, Object level) { private void testRateLimits(LimitedApi limitedApi, int max, Object level) {
for (int i = 1; i <= max; i++) { for (int i = 1; i <= max; i++) {
boolean success = rateLimitService.checkRateLimit(limitedApi, tenantId, level); boolean success = rateLimitService.checkRateLimit(limitedApi, tenantId, level);
assertTrue(success); Assertions.assertTrue(success);
} }
boolean success = rateLimitService.checkRateLimit(limitedApi, tenantId, level); boolean success = rateLimitService.checkRateLimit(limitedApi, tenantId, level);
assertFalse(success); Assertions.assertFalse(success);
} }
private void updateTenantProfileConfiguration(DefaultTenantProfileConfiguration profileConfiguration) { private void updateTenantProfileConfiguration(DefaultTenantProfileConfiguration profileConfiguration) {

18
application/src/test/java/org/thingsboard/server/service/queue/ruleengine/TbRuleEngineQueueConsumerManagerTest.java
View File

@ -18,13 +18,15 @@ package org.thingsboard.server.service.queue.ruleengine;
import lombok.Getter; import lombok.Getter;
import lombok.SneakyThrows; import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.junit.After; import org.junit.jupiter.api.AfterEach;
import org.junit.Before; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.testcontainers.shaded.org.apache.commons.lang3.RandomUtils; import org.testcontainers.shaded.org.apache.commons.lang3.RandomUtils;
import org.thingsboard.common.util.JacksonUtil; import org.thingsboard.common.util.JacksonUtil;
import org.thingsboard.common.util.ThingsBoardExecutors; import org.thingsboard.common.util.ThingsBoardExecutors;
@ -95,7 +97,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@Slf4j @Slf4j
@RunWith(MockitoJUnitRunner.class) @MockitoSettings(strictness = Strictness.LENIENT)
public class TbRuleEngineQueueConsumerManagerTest { public class TbRuleEngineQueueConsumerManagerTest {
@Mock @Mock
@ -128,7 +130,7 @@ public class TbRuleEngineQueueConsumerManagerTest {
private AtomicInteger totalConsumedMsgs; private AtomicInteger totalConsumedMsgs;
private AtomicInteger totalProcessedMsgs; private AtomicInteger totalProcessedMsgs;
@Before @BeforeEach
public void beforeEach() { public void beforeEach() {
ruleEngineConsumerContext = new TbRuleEngineConsumerContext( ruleEngineConsumerContext = new TbRuleEngineConsumerContext(
actorContext, statsFactory, spy(new TbRuleEngineSubmitStrategyFactory()), actorContext, statsFactory, spy(new TbRuleEngineSubmitStrategyFactory()),
@ -190,7 +192,7 @@ public class TbRuleEngineQueueConsumerManagerTest {
.build(); .build();
} }
@After @AfterEach
public void afterEach() { public void afterEach() {
consumerManager.stop(); consumerManager.stop();
consumerManager.awaitStop(); consumerManager.awaitStop();

12
application/src/test/java/org/thingsboard/server/service/sms/smpp/SmppSmsSenderTest.java
View File

@ -15,10 +15,10 @@
*/ */
package org.thingsboard.server.service.sms.smpp; package org.thingsboard.server.service.sms.smpp;
import org.junit.Before; import org.junit.jupiter.api.BeforeEach;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith; import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.MockitoJUnitRunner; import org.mockito.junit.jupiter.MockitoExtension;
import org.smpp.Session; import org.smpp.Session;
import org.smpp.pdu.SubmitSMResp; import org.smpp.pdu.SubmitSMResp;
import org.thingsboard.server.common.data.StringUtils; import org.thingsboard.server.common.data.StringUtils;
@ -35,14 +35,14 @@ import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when; import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class) @ExtendWith(MockitoExtension.class)
public class SmppSmsSenderTest { public class SmppSmsSenderTest {
SmppSmsSender smppSmsSender; SmppSmsSender smppSmsSender;
SmppSmsProviderConfiguration smppConfig; SmppSmsProviderConfiguration smppConfig;
Session smppSession; Session smppSession;
@Before @BeforeEach
public void beforeEach() throws Exception { public void beforeEach() throws Exception {
Constructor<SmppSmsSender> constructor = SmppSmsSender.class.getDeclaredConstructor(); Constructor<SmppSmsSender> constructor = SmppSmsSender.class.getDeclaredConstructor();
constructor.setAccessible(true); constructor.setAccessible(true);

2
common/transport/lwm2m/src/main/java/org/thingsboard/server/transport/lwm2m/server/client/LwM2mClient.java
View File

@ -460,7 +460,7 @@ public class LwM2mClient {
if (lwM2mPath.isObject()) { if (lwM2mPath.isObject()) {
LwM2m.Version ver; LwM2m.Version ver;
if (link.getAttributes().get("ver")!= null) { if (link.getAttributes().get("ver")!= null) {
ver = (Version) link.getAttributes().get("ver").getValue(); ver = new LwM2m.Version(link.getAttributes().get("ver").getValue().toString());
} else { } else {
ver = getDefaultObjectIDVer(); ver = getDefaultObjectIDVer();
} }

2
monitoring/src/main/java/org/thingsboard/monitoring/service/transport/TransportHealthChecker.java
View File

@ -145,7 +145,7 @@ public abstract class TransportHealthChecker<C extends TransportMonitoringConfig
profileData.setTransportConfiguration(new DefaultDeviceProfileTransportConfiguration()); profileData.setTransportConfiguration(new DefaultDeviceProfileTransportConfiguration());
deviceProfile.setProfileData(profileData); deviceProfile.setProfileData(profileData);
} else { } else {
tbClient.getResources(new PageLink(1, 0, "lwm2m monitoring")).getData() tbClient.getResources(new PageLink(1, 0, "LwM2M Monitoring id=3 v1.0")).getData()
.stream().findFirst() .stream().findFirst()
.orElseGet(() -> { .orElseGet(() -> {
TbResource newResource = ResourceUtils.getResource("lwm2m/resource.json", TbResource.class); TbResource newResource = ResourceUtils.getResource("lwm2m/resource.json", TbResource.class);

30
rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/profile/AlarmState.java
View File

@ -244,27 +244,27 @@ class AlarmState {
return null; return null;
} }
} else { } else {
currentAlarm = new Alarm(); var newAlarm = new Alarm();
currentAlarm.setType(alarmDefinition.getAlarmType()); newAlarm.setType(alarmDefinition.getAlarmType());
currentAlarm.setAcknowledged(false); newAlarm.setAcknowledged(false);
currentAlarm.setCleared(false); newAlarm.setCleared(false);
currentAlarm.setSeverity(severity); newAlarm.setSeverity(severity);
long startTs = dataSnapshot.getTs(); long startTs = dataSnapshot.getTs();
if (startTs == 0L) { if (startTs == 0L) {
startTs = System.currentTimeMillis(); startTs = System.currentTimeMillis();
} }
currentAlarm.setStartTs(startTs); newAlarm.setStartTs(startTs);
currentAlarm.setEndTs(currentAlarm.getStartTs()); newAlarm.setEndTs(startTs);
currentAlarm.setDetails(createDetails(ruleState)); newAlarm.setDetails(createDetails(ruleState));
currentAlarm.setOriginator(originator); newAlarm.setOriginator(originator);
currentAlarm.setTenantId(ctx.getTenantId()); newAlarm.setTenantId(ctx.getTenantId());
currentAlarm.setPropagate(alarmDefinition.isPropagate()); newAlarm.setPropagate(alarmDefinition.isPropagate());
currentAlarm.setPropagateToOwner(alarmDefinition.isPropagateToOwner()); newAlarm.setPropagateToOwner(alarmDefinition.isPropagateToOwner());
currentAlarm.setPropagateToTenant(alarmDefinition.isPropagateToTenant()); newAlarm.setPropagateToTenant(alarmDefinition.isPropagateToTenant());
if (alarmDefinition.getPropagateRelationTypes() != null) { if (alarmDefinition.getPropagateRelationTypes() != null) {
currentAlarm.setPropagateRelationTypes(alarmDefinition.getPropagateRelationTypes()); newAlarm.setPropagateRelationTypes(alarmDefinition.getPropagateRelationTypes());
} }
AlarmApiCallResult result = ctx.getAlarmService().createAlarm(AlarmCreateOrUpdateActiveRequest.fromAlarm(currentAlarm)); AlarmApiCallResult result = ctx.getAlarmService().createAlarm(AlarmCreateOrUpdateActiveRequest.fromAlarm(newAlarm));
currentAlarm = result.getAlarm(); currentAlarm = result.getAlarm();
return TbAlarmResult.fromAlarmResult(result); return TbAlarmResult.fromAlarmResult(result);
} }