refactor relation service and dao(*), remove redundant todo's, refactor tests

(*): resolve immediate .get() invocation, which producing blocking (checkRelation method), by adding sync checkRelation method and refactor the usages of checkRelationAsync

application/src/main/java/org/thingsboard/server/service/edge/rpc/sync/DefaultEdgeRequestsService.java

@@ -348,7 +348,7 @@ public class DefaultEdgeRequestsService implements EdgeRequestsService {
                     if (entityViews != null && !entityViews.isEmpty()) {
                         List<ListenableFuture<Boolean>> futures = new ArrayList<>();
                         for (EntityView entityView : entityViews) {
-                            ListenableFuture<Boolean> future = relationService.checkRelation(tenantId, edge.getId(), entityView.getId(),
+                            ListenableFuture<Boolean> future = relationService.checkRelationAsync(tenantId, edge.getId(), entityView.getId(),
                                     EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE);
                             futures.add(future);
                             Futures.addCallback(future, new FutureCallback<>() {

common/dao-api/src/main/java/org/thingsboard/server/dao/relation/RelationService.java

@@ -34,7 +34,9 @@ import java.util.List;
  */
 public interface RelationService {
 
-    ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<Boolean> checkRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+
+    Boolean checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
     EntityRelation getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 

dao/src/main/java/org/thingsboard/server/dao/alarm/BaseAlarmService.java

@@ -431,7 +431,6 @@ public class BaseAlarmService extends AbstractEntityService implements AlarmServ
                         throw new DataValidationException("Alarm should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(alarm.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Alarm is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/asset/BaseAssetService.java

@@ -412,7 +412,6 @@ public class BaseAssetService extends AbstractEntityService implements AssetServ
                         throw new DataValidationException("Asset should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(asset.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Asset is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/customer/CustomerServiceImpl.java

@@ -211,7 +211,6 @@ public class CustomerServiceImpl extends AbstractEntityService implements Custom
                         throw new DataValidationException("Customer should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(customer.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Customer is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/dashboard/DashboardServiceImpl.java

@@ -309,7 +309,6 @@ public class DashboardServiceImpl extends AbstractEntityService implements Dashb
                         throw new DataValidationException("Dashboard should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(dashboard.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Dashboard is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/device/DeviceProfileServiceImpl.java

@@ -376,7 +376,6 @@ public class DeviceProfileServiceImpl extends AbstractEntityService implements D
                         throw new DataValidationException("Device profile should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(deviceProfile.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Device profile is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/device/DeviceServiceImpl.java

@@ -732,7 +732,6 @@ public class DeviceServiceImpl extends AbstractEntityService implements DeviceSe
                         throw new DataValidationException("Device should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(device.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Device is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/edge/EdgeServiceImpl.java

@@ -414,7 +414,6 @@ public class EdgeServiceImpl extends AbstractEntityService implements EdgeServic
                         throw new DataValidationException("Edge should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(edge.getTenantId());
-                        // TODO: 13.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Edge is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/entity/AbstractEntityService.java

@@ -82,20 +82,16 @@ public abstract class AbstractEntityService {
     }
 
     protected void checkAssignedEntityViewsToEdge(TenantId tenantId, EntityId entityId, EdgeId edgeId) {
-        try {
-            List<EntityView> entityViews = entityViewService.findEntityViewsByTenantIdAndEntityId(tenantId, entityId);
-            if (entityViews != null && !entityViews.isEmpty()) {
-                EntityView entityView = entityViews.get(0);
-                // TODO: @voba - refactor this blocking operation
-                Boolean relationExists = relationService.checkRelation(tenantId, edgeId, entityView.getId(),
-                        EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE).get();
-                if (relationExists) {
-                    throw new DataValidationException("Can't unassign device/asset from edge that is related to entity view and entity view is assigned to edge!");
-                }
+        List<EntityView> entityViews = entityViewService.findEntityViewsByTenantIdAndEntityId(tenantId, entityId);
+        if (entityViews != null && !entityViews.isEmpty()) {
+            EntityView entityView = entityViews.get(0);
+            Boolean relationExists = relationService.checkRelation(
+                    tenantId, edgeId, entityView.getId(),
+                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE
+            );
+            if (relationExists) {
+                throw new DataValidationException("Can't unassign device/asset from edge that is related to entity view and entity view is assigned to edge!");
             }
-        } catch (Exception e) {
-            log.error("[{}] Exception while finding entity views for entityId [{}]", tenantId, entityId, e);
-            throw new RuntimeException("Exception while finding entity views for entityId [" + entityId + "]", e);
         }
     }
 

dao/src/main/java/org/thingsboard/server/dao/entityview/EntityViewServiceImpl.java

@@ -308,9 +308,7 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
         validateId(tenantId, INCORRECT_TENANT_ID + tenantId);
         validateId(entityId.getId(), "Incorrect entityId" + entityId);
 
-        List<Object> tenantIdAndEntityId = new ArrayList<>();
-        tenantIdAndEntityId.add(tenantId);
-        tenantIdAndEntityId.add(entityId);
+        List<Object> tenantIdAndEntityId = List.of(tenantId, entityId);
 
         Cache cache = cacheManager.getCache(ENTITY_VIEW_CACHE);
         List<EntityView> fromCache = cache.get(tenantIdAndEntityId, List.class);
@@ -366,15 +364,10 @@ public class EntityViewServiceImpl extends AbstractEntityService implements Enti
             throw new DataValidationException("Can't assign entityView to edge from different tenant!");
         }
 
-        try {
-            Boolean relationExists = relationService.checkRelation(tenantId, edgeId, entityView.getEntityId(),
-                    EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE).get();
-            if (!relationExists) {
-                throw new DataValidationException("Can't assign entity view to edge because related device/asset doesn't assigned to edge!");
-            }
-        } catch (ExecutionException | InterruptedException e) {
-            log.error("Exception during relation check", e);
-            throw new RuntimeException("Exception during relation check", e);
+        Boolean relationExists = relationService.checkRelation(tenantId, edgeId, entityView.getEntityId(),
+                EntityRelation.CONTAINS_TYPE, RelationTypeGroup.EDGE);
+        if (!relationExists) {
+            throw new DataValidationException("Can't assign entity view to edge because related device/asset doesn't assigned to edge!");
         }
 
         try {

dao/src/main/java/org/thingsboard/server/dao/relation/BaseRelationService.java

@@ -30,11 +30,8 @@ import org.springframework.cache.annotation.Caching;
 import org.springframework.dao.ConcurrencyFailureException;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
-import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.common.data.page.PageData;
-import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.relation.EntityRelation;
 import org.thingsboard.server.common.data.relation.EntityRelationInfo;
 import org.thingsboard.server.common.data.relation.EntityRelationsQuery;
@@ -77,10 +74,15 @@ public class BaseRelationService implements RelationService {
     private CacheManager cacheManager;
 
     @Override
-    public ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<Boolean> checkRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         log.trace("Executing checkRelation [{}][{}][{}][{}]", from, to, relationType, typeGroup);
         validate(from, to, relationType, typeGroup);
-        return relationDao.checkRelation(tenantId, from, to, relationType, typeGroup);
+        return relationDao.checkRelationAsync(tenantId, from, to, relationType, typeGroup);
+    }
+
+    @Override
+    public Boolean checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+        return null;
     }
 
     @Cacheable(cacheNames = RELATIONS_CACHE, key = "{#from, #to, #relationType, #typeGroup}")

dao/src/main/java/org/thingsboard/server/dao/relation/RelationDao.java

@@ -41,7 +41,9 @@ public interface RelationDao {
 
     ListenableFuture<List<EntityRelation>> findAllByToAndType(TenantId tenantId, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
-    ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+    ListenableFuture<Boolean> checkRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
+
+    Boolean checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 
     ListenableFuture<EntityRelation> getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup);
 

dao/src/main/java/org/thingsboard/server/dao/resource/BaseResourceService.java

@@ -184,7 +184,6 @@ public class BaseResourceService implements ResourceService {
             }
             if (!resource.getTenantId().getId().equals(ModelConstants.NULL_UUID)) {
                 Tenant tenant = tenantService.findTenantById(resource.getTenantId());
-                // TODO: 12.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                 if (tenant == null) {
                     throw new DataValidationException("Resource is referencing to non-existent tenant!");
                 }

dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java

@@ -727,7 +727,6 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
                         throw new DataValidationException("Rule chain should be assigned to tenant!");
                     }
                     Tenant tenant = tenantService.findTenantById(ruleChain.getTenantId());
-                    // TODO: 12.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                     if (tenant == null) {
                         throw new DataValidationException("Rule chain is referencing to non-existent tenant!");
                     }

dao/src/main/java/org/thingsboard/server/dao/sql/entityview/EntityViewRepository.java

@@ -20,7 +20,6 @@ import org.springframework.data.domain.Pageable;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
-import org.thingsboard.server.dao.model.sql.DeviceEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewInfoEntity;
 

dao/src/main/java/org/thingsboard/server/dao/sql/relation/JpaRelationDao.java

@@ -101,11 +101,17 @@ public class JpaRelationDao extends JpaAbstractDaoListeningExecutorService imple
     }
 
     @Override
-    public ListenableFuture<Boolean> checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+    public ListenableFuture<Boolean> checkRelationAsync(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         RelationCompositeKey key = getRelationCompositeKey(from, to, relationType, typeGroup);
         return service.submit(() -> relationRepository.existsById(key));
     }
 
+    @Override
+    public Boolean checkRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
+        RelationCompositeKey key = getRelationCompositeKey(from, to, relationType, typeGroup);
+        return relationRepository.existsById(key);
+    }
+
     @Override
     public ListenableFuture<EntityRelation> getRelation(TenantId tenantId, EntityId from, EntityId to, String relationType, RelationTypeGroup typeGroup) {
         RelationCompositeKey key = getRelationCompositeKey(from, to, relationType, typeGroup);

dao/src/main/java/org/thingsboard/server/dao/usagerecord/ApiUsageStateServiceImpl.java

@@ -165,7 +165,6 @@ public class ApiUsageStateServiceImpl extends AbstractEntityService implements A
                         throw new DataValidationException("ApiUsageState should be assigned to tenant!");
                     } else {
                         Tenant tenant = tenantService.findTenantById(apiUsageState.getTenantId());
-                        // TODO: 12.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null && !requestTenantId.equals(TenantId.SYS_TENANT_ID)) {
                             throw new DataValidationException("ApiUsageState is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/widget/WidgetTypeServiceImpl.java

@@ -139,7 +139,6 @@ public class WidgetTypeServiceImpl implements WidgetTypeService {
                     }
                     if (!widgetTypeDetails.getTenantId().getId().equals(ModelConstants.NULL_UUID)) {
                         Tenant tenant = tenantService.findTenantById(widgetTypeDetails.getTenantId());
-                        // TODO: 12.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Widget type is referencing to non-existent tenant!");
                         }

dao/src/main/java/org/thingsboard/server/dao/widget/WidgetsBundleServiceImpl.java

@@ -163,7 +163,6 @@ public class WidgetsBundleServiceImpl implements WidgetsBundleService {
                     }
                     if (!widgetsBundle.getTenantId().getId().equals(ModelConstants.NULL_UUID)) {
                         Tenant tenant = tenantService.findTenantById(widgetsBundle.getTenantId());
-                        // TODO: 12.01.22 Instead of finding and checking for null need to create and use tenantService.exists()
                         if (tenant == null) {
                             throw new DataValidationException("Widgets bundle is referencing to non-existent tenant!");
                         }

dao/src/test/java/org/thingsboard/server/dao/service/BaseOtaPackageServiceTest.java

@@ -97,26 +97,26 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
 
         Assert.assertEquals(0, otaPackageService.sumDataSizeByTenantId(tenantId));
 
-        createFirmware(tenantId, "1");
+        createAndSaveFirmware(tenantId, "1");
         Assert.assertEquals(1, otaPackageService.sumDataSizeByTenantId(tenantId));
 
         thrown.expect(DataValidationException.class);
         thrown.expectMessage(String.format("Failed to create the ota package, files size limit is exhausted %d bytes!", DATA_SIZE));
-        createFirmware(tenantId, "2");
+        createAndSaveFirmware(tenantId, "2");
     }
 
     @Test
     public void sumDataSizeByTenantId() {
         Assert.assertEquals(0, otaPackageService.sumDataSizeByTenantId(tenantId));
 
-        createFirmware(tenantId, "0.1");
+        createAndSaveFirmware(tenantId, "0.1");
         Assert.assertEquals(1, otaPackageService.sumDataSizeByTenantId(tenantId));
 
         int maxSumDataSize = 8;
         List<OtaPackage> packages = new ArrayList<>(maxSumDataSize);
 
         for (int i = 2; i <= maxSumDataSize; i++) {
-            packages.add(createFirmware(tenantId, "0." + i));
+            packages.add(createAndSaveFirmware(tenantId, "0." + i));
             Assert.assertEquals(i, otaPackageService.sumDataSizeByTenantId(tenantId));
         }
 
@@ -419,15 +419,15 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
 
     @Test
     public void testSaveFirmwareWithExistingTitleAndVersion() {
-        createFirmware(tenantId, VERSION);
+        createAndSaveFirmware(tenantId, VERSION);
         thrown.expect(DataValidationException.class);
         thrown.expectMessage("OtaPackage with such title and version already exists!");
-        createFirmware(tenantId, VERSION);
+        createAndSaveFirmware(tenantId, VERSION);
     }
 
     @Test
     public void testDeleteFirmwareWithReferenceByDevice() {
-        OtaPackage savedFirmware = createFirmware(tenantId, VERSION);
+        OtaPackage savedFirmware = createAndSaveFirmware(tenantId, VERSION);
 
         Device device = new Device();
         device.setTenantId(tenantId);
@@ -448,7 +448,7 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
 
     @Test
     public void testUpdateDeviceProfileId() {
-        OtaPackage savedFirmware = createFirmware(tenantId, VERSION);
+        OtaPackage savedFirmware = createAndSaveFirmware(tenantId, VERSION);
 
         try {
             thrown.expect(DataValidationException.class);
@@ -494,7 +494,7 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
 
     @Test
     public void testFindFirmwareById() {
-        OtaPackage savedFirmware = createFirmware(tenantId, VERSION);
+        OtaPackage savedFirmware = createAndSaveFirmware(tenantId, VERSION);
 
         OtaPackage foundFirmware = otaPackageService.findOtaPackageById(tenantId, savedFirmware.getId());
         Assert.assertNotNull(foundFirmware);
@@ -520,7 +520,7 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
 
     @Test
     public void testDeleteFirmware() {
-        OtaPackage savedFirmware = createFirmware(tenantId, VERSION);
+        OtaPackage savedFirmware = createAndSaveFirmware(tenantId, VERSION);
 
         OtaPackage foundFirmware = otaPackageService.findOtaPackageById(tenantId, savedFirmware.getId());
         Assert.assertNotNull(foundFirmware);
@@ -533,7 +533,7 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
     public void testFindTenantFirmwaresByTenantId() {
         List<OtaPackageInfo> firmwares = new ArrayList<>();
         for (int i = 0; i < 165; i++) {
-            OtaPackageInfo info = new OtaPackageInfo(createFirmware(tenantId, VERSION + i));
+            OtaPackageInfo info = new OtaPackageInfo(createAndSaveFirmware(tenantId, VERSION + i));
             info.setHasData(true);
             firmwares.add(info);
         }
@@ -580,7 +580,7 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
     public void testFindTenantFirmwaresByTenantIdAndHasData() {
         List<OtaPackageInfo> firmwares = new ArrayList<>();
         for (int i = 0; i < 165; i++) {
-            firmwares.add(new OtaPackageInfo(otaPackageService.saveOtaPackage(createFirmware(tenantId, VERSION + i))));
+            firmwares.add(new OtaPackageInfo(otaPackageService.saveOtaPackage(createAndSaveFirmware(tenantId, VERSION + i))));
         }
 
         OtaPackageInfo firmwareWithUrl = new OtaPackageInfo();
@@ -696,7 +696,15 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
         otaPackageService.saveOtaPackageInfo(firmwareInfo, true);
     }
 
-    private OtaPackage createFirmware(TenantId tenantId, String version) {
+    private OtaPackage createAndSaveFirmware(TenantId tenantId, String version) {
+        return otaPackageService.saveOtaPackage(createFirmware(tenantId, version, deviceProfileId));
+    }
+
+    public static OtaPackage createFirmware(
+            TenantId tenantId,
+            String version,
+            DeviceProfileId deviceProfileId
+    ) {
         OtaPackage firmware = new OtaPackage();
         firmware.setTenantId(tenantId);
         firmware.setDeviceProfileId(deviceProfileId);
@@ -709,6 +717,6 @@ public abstract class BaseOtaPackageServiceTest extends AbstractServiceTest {
         firmware.setChecksum(CHECKSUM);
         firmware.setData(DATA);
         firmware.setDataSize(DATA_SIZE);
-        return otaPackageService.saveOtaPackage(firmware);
+        return firmware;
     }
 }

dao/src/test/java/org/thingsboard/server/dao/service/BaseRelationServiceTest.java

@@ -57,13 +57,13 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
         Assert.assertTrue(saveRelation(relation));
 
-        Assert.assertTrue(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
+        Assert.assertTrue(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
 
-        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, "NOT_EXISTING_TYPE", RelationTypeGroup.COMMON).get());
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, "NOT_EXISTING_TYPE", RelationTypeGroup.COMMON));
 
-        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, parentId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, parentId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
 
-        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, parentId, "NOT_EXISTING_TYPE", RelationTypeGroup.COMMON).get());
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, parentId, "NOT_EXISTING_TYPE", RelationTypeGroup.COMMON));
     }
 
     @Test
@@ -80,9 +80,9 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
         Assert.assertTrue(relationService.deleteRelationAsync(SYSTEM_TENANT_ID, relationA).get());
 
-        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
+         Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
 
-        Assert.assertTrue(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
+        Assert.assertTrue(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
 
         Assert.assertTrue(relationService.deleteRelationAsync(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
     }
@@ -118,9 +118,9 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
         Assert.assertNull(relationService.deleteEntityRelationsAsync(SYSTEM_TENANT_ID, childId).get());
 
-        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, parentId, childId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
 
-        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON).get());
+        Assert.assertFalse(relationService.checkRelation(SYSTEM_TENANT_ID, childId, subChildId, EntityRelation.CONTAINS_TYPE, RelationTypeGroup.COMMON));
     }
 
     @Test

dao/src/test/java/org/thingsboard/server/dao/service/BaseTenantServiceTest.java

@@ -17,6 +17,7 @@ package org.thingsboard.server.dao.service;
 
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.Assert;
+import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -46,9 +47,7 @@ import org.thingsboard.server.common.data.asset.Asset;
 import org.thingsboard.server.common.data.device.profile.DeviceProfileData;
 import org.thingsboard.server.common.data.device.profile.MqttDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.edge.Edge;
-import org.thingsboard.server.common.data.id.DeviceProfileId;
 import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.common.data.ota.ChecksumAlgorithm;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.common.data.rpc.Rpc;
@@ -62,7 +61,6 @@ import org.thingsboard.server.common.data.widget.WidgetsBundle;
 import org.thingsboard.server.dao.exception.DataValidationException;
 import org.thingsboard.server.dao.tenant.TenantDao;
 
-import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -71,9 +69,8 @@ import java.util.Set;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
-import static org.thingsboard.server.common.data.ota.OtaPackageType.FIRMWARE;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public abstract class BaseTenantServiceTest extends AbstractServiceTest {
 
@@ -85,6 +82,13 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
     @Autowired
     CacheManager cacheManager;
 
+    private Cache tenantCache;
+
+    @Before
+    public void setup() {
+        tenantCache = cacheManager.getCache(CacheConstants.TENANTS_CACHE);
+    }
+
     @Test
     public void testSaveTenant() {
         Tenant tenant = new Tenant();
@@ -330,15 +334,15 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         tenant.setTitle("My tenant");
         Tenant savedTenant = tenantService.saveTenant(tenant);
 
-        reset(tenantDao);
-        Objects.requireNonNull(cacheManager.getCache(CacheConstants.TENANTS_CACHE), "Tenant cache manager is null").evict(savedTenant.getId());
+        Mockito.reset(tenantDao);
+        Objects.requireNonNull(tenantCache, "Tenant cache manager is null").evict(savedTenant.getId());
 
         verify(tenantDao, Mockito.times(0)).findById(any(), any());
         tenantService.findTenantById(savedTenant.getId());
         verify(tenantDao, Mockito.times(1)).findById(eq(savedTenant.getId()), eq(savedTenant.getId().getId()));
 
         Cache.ValueWrapper cachedTenant =
-                Objects.requireNonNull(cacheManager.getCache(CacheConstants.TENANTS_CACHE), "Cache manager is null!").get(savedTenant.getId());
+                Objects.requireNonNull(tenantCache, "Cache manager is null!").get(savedTenant.getId());
         Assert.assertNotNull("Getting an existing Tenant doesn't add it to the cache!", cachedTenant);
 
         for (int i = 0; i < 100; i++) {
@@ -356,15 +360,15 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         Tenant savedTenant = tenantService.saveTenant(tenant);
 
         Cache.ValueWrapper cachedTenant =
-                Objects.requireNonNull(cacheManager.getCache(CacheConstants.TENANTS_CACHE), "Cache manager is null!").get(savedTenant.getId());
+                Objects.requireNonNull(tenantCache, "Cache manager is null!").get(savedTenant.getId());
         Assert.assertNotNull("Saving a Tenant doesn't add it to the cache!", cachedTenant);
 
         savedTenant.setTitle("My new tenant");
         savedTenant = tenantService.saveTenant(savedTenant);
 
-        reset(tenantDao);
+        Mockito.reset(tenantDao);
 
-        cachedTenant = Objects.requireNonNull(cacheManager.getCache(CacheConstants.TENANTS_CACHE), "Cache manager is null!").get(savedTenant.getId());
+        cachedTenant = Objects.requireNonNull(tenantCache, "Cache manager is null!").get(savedTenant.getId());
         Assert.assertNull("Updating a Tenant doesn't evict the cache!", cachedTenant);
 
         verify(tenantDao, Mockito.times(0)).findById(any(), any());
@@ -381,184 +385,168 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         Tenant savedTenant = tenantService.saveTenant(tenant);
 
         Cache.ValueWrapper cachedTenant =
-                Objects.requireNonNull(cacheManager.getCache(CacheConstants.TENANTS_CACHE), "Cache manager is null!").get(savedTenant.getId());
+                Objects.requireNonNull(tenantCache, "Cache manager is null!").get(savedTenant.getId());
         Assert.assertNotNull("Saving a Tenant doesn't add it to the cache!", cachedTenant);
 
         tenantService.deleteTenant(savedTenant.getId());
-        cachedTenant = Objects.requireNonNull(cacheManager.getCache(CacheConstants.TENANTS_CACHE), "Cache manager is null!").get(savedTenant.getId());
+        cachedTenant = Objects.requireNonNull(tenantCache, "Cache manager is null!").get(savedTenant.getId());
         Assert.assertNull("Removing a Tenant doesn't evict the cache!", cachedTenant);
     }
 
     @Test
     public void testDeleteTenantDeletingAllRelatedEntities() throws Exception {
-        TenantProfile savedProfile = createAndSaveTenantProfile();
-        Tenant savedTenant = createAndSaveTenant(savedProfile);
-        User savedUser = createAndSaveUserFor(savedTenant);
-        Customer savedCustomer = createAndSaveCustomerFor(savedTenant);
-        WidgetsBundle savedWidgetsBundle = createAndSaveWidgetBundleFor(savedTenant);
-        DeviceProfile savedDeviceProfile = createAndSaveDeviceProfileWithProfileDataFor(savedTenant);
-        Device savedDevice = createAndSaveDeviceFor(savedTenant, savedCustomer, savedDeviceProfile);
-        EntityView savedEntityView = createAndSaveEntityViewFor(savedTenant, savedCustomer, savedDevice);
-        Asset savedAsset = createAndSaveAssetFor(savedTenant, savedCustomer);
-        Dashboard savedDashboard = createAndSaveDashboardFor(savedTenant, savedCustomer);
-        RuleChain savedRuleChain = createAndSaveRuleChainFor(savedTenant);
-        Edge savedEdge = createAndSaveEdgeFor(savedTenant);
-        OtaPackage savedOtaPackage = createAndSaveOtaPackageFor(savedTenant, savedDeviceProfile);
-        TbResource savedResource = createAndSaveResourceFor(savedTenant);
-        Rpc savedRpc = createAndSaveRpcFor(savedTenant, savedDevice);
-
-        tenantService.deleteTenant(savedTenant.getId());
-
-        Assert.assertNull(tenantService.findTenantById(savedTenant.getId()));
-        assertCustomerIsDeleted(savedTenant, savedCustomer);
-        assertWidgetsBundleIsDeleted(savedTenant, savedWidgetsBundle);
-        assertEntityViewIsDeleted(savedTenant, savedDevice, savedEntityView);
-        assertAssetIsDeleted(savedTenant, savedAsset);
-        assertDeviceIsDeleted(savedTenant, savedDevice);
-        assertDeviceProfileIsDeleted(savedTenant, savedDeviceProfile);
-        assertDashboardIsDeleted(savedTenant, savedDashboard);
-        assertEdgeIsDeleted(savedTenant, savedEdge);
-        assertTenantAdminIsDeleted(savedTenant);
-        assertUserIsDeleted(savedTenant, savedUser);
-        Assert.assertNull(ruleChainService.findRuleChainById(savedTenant.getId(), savedRuleChain.getId()));
-        Assert.assertNull(apiUsageStateService.findTenantApiUsageState(savedTenant.getId()));
-        assertResourceIsDeleted(savedTenant, savedResource);
-        assertOtaPackageIsDeleted(savedTenant, savedOtaPackage);
-        Assert.assertNull(rpcService.findById(savedTenant.getId(), savedRpc.getId()));
-
-        tenantProfileService.deleteTenantProfile(TenantId.SYS_TENANT_ID, savedProfile.getId());
-    }
-
-    private void assertOtaPackageIsDeleted(Tenant savedTenant, OtaPackage savedOtaPackage) {
-        Assert.assertNull(
-                otaPackageService.findOtaPackageById(
-                        savedTenant.getId(), savedOtaPackage.getId()
-                )
-        );
-        PageLink pageLinkOta = new PageLink(1000);
-        PageData<OtaPackageInfo> pageDataOta = otaPackageService.findTenantOtaPackagesByTenantId(savedTenant.getId(), pageLinkOta);
-        Assert.assertFalse(pageDataOta.hasNext());
+        TenantProfile profile = createAndSaveTenantProfile();
+        Tenant tenant = createAndSaveTenant(profile);
+        User user = createAndSaveUserFor(tenant);
+        Customer customer = createAndSaveCustomerFor(tenant);
+        WidgetsBundle widgetsBundle = createAndSaveWidgetBundleFor(tenant);
+        DeviceProfile deviceProfile = createAndSaveDeviceProfileWithProfileDataFor(tenant);
+        Device device = createAndSaveDeviceFor(tenant, customer, deviceProfile);
+        EntityView entityView = createAndSaveEntityViewFor(tenant, customer, device);
+        Asset asset = createAndSaveAssetFor(tenant, customer);
+        Dashboard dashboard = createAndSaveDashboardFor(tenant, customer);
+        RuleChain ruleChain = createAndSaveRuleChainFor(tenant);
+        Edge edge = createAndSaveEdgeFor(tenant);
+        OtaPackage otaPackage = createAndSaveOtaPackageFor(tenant, deviceProfile);
+        TbResource resource = createAndSaveResourceFor(tenant);
+        Rpc rpc = createAndSaveRpcFor(tenant, device);
+
+        tenantService.deleteTenant(tenant.getId());
+
+        Assert.assertNull(tenantService.findTenantById(tenant.getId()));
+        assertCustomerIsDeleted(tenant, customer);
+        assertWidgetsBundleIsDeleted(tenant, widgetsBundle);
+        assertEntityViewIsDeleted(tenant, device, entityView);
+        assertAssetIsDeleted(tenant, asset);
+        assertDeviceIsDeleted(tenant, device);
+        assertDeviceProfileIsDeleted(tenant, deviceProfile);
+        assertDashboardIsDeleted(tenant, dashboard);
+        assertEdgeIsDeleted(tenant, edge);
+        assertTenantAdminIsDeleted(tenant);
+        assertUserIsDeleted(tenant, user);
+        Assert.assertNull(ruleChainService.findRuleChainById(tenant.getId(), ruleChain.getId()));
+        Assert.assertNull(apiUsageStateService.findTenantApiUsageState(tenant.getId()));
+        assertResourceIsDeleted(tenant, resource);
+        assertOtaPackageIsDeleted(tenant, otaPackage);
+        Assert.assertNull(rpcService.findById(tenant.getId(), rpc.getId()));
+
+        tenantProfileService.deleteTenantProfile(TenantId.SYS_TENANT_ID, profile.getId());
+    }
+
+    private void assertOtaPackageIsDeleted(Tenant tenant, OtaPackage otaPackage) {
+        assertThat(otaPackageService.findOtaPackageById(tenant.getId(), otaPackage.getId()))
+                .as("otaPackage").isNull();
+        PageLink pageLinkOta = new PageLink(1);
+        PageData<OtaPackageInfo> pageDataOta = otaPackageService.findTenantOtaPackagesByTenantId(tenant.getId(), pageLinkOta);
         Assert.assertEquals(0, pageDataOta.getTotalElements());
     }
 
-    private void assertResourceIsDeleted(Tenant savedTenant, TbResource savedResource) {
-        Assert.assertNull(resourceService.findResourceById(savedTenant.getId(), savedResource.getId()));
-        PageLink pageLinkResources = new PageLink(1000);
+    private void assertResourceIsDeleted(Tenant tenant, TbResource resource) {
+        assertThat(resourceService.findResourceById(tenant.getId(), resource.getId()))
+                .as("resource").isNull();
+        PageLink pageLinkResources = new PageLink(1);
         PageData<TbResourceInfo> tenantResources =
-                resourceService.findAllTenantResourcesByTenantId(savedTenant.getId(), pageLinkResources);
-        Assert.assertFalse(tenantResources.hasNext());
+                resourceService.findAllTenantResourcesByTenantId(tenant.getId(), pageLinkResources);
         Assert.assertEquals(0, tenantResources.getTotalElements());
     }
 
-    private void assertUserIsDeleted(Tenant savedTenant, User savedUser) {
-        Assert.assertNull(userService.findUserById(savedTenant.getId(), savedUser.getId()));
-        PageLink pageLinkUsers = new PageLink(1000);
+    private void assertUserIsDeleted(Tenant tenant, User user) {
+        assertThat(userService.findUserById(tenant.getId(), user.getId()))
+                .as("user").isNull();
+        PageLink pageLinkUsers = new PageLink(1);
         PageData<User> users =
-                userService.findUsersByTenantId(savedTenant.getId(), pageLinkUsers);
-        Assert.assertFalse(users.hasNext());
+                userService.findUsersByTenantId(tenant.getId(), pageLinkUsers);
         Assert.assertEquals(0, users.getTotalElements());
     }
 
     private void assertTenantAdminIsDeleted(Tenant savedTenant) {
-        PageLink pageLinkTenantAdmins = new PageLink(1000);
+        PageLink pageLinkTenantAdmins = new PageLink(1);
         PageData<User> tenantAdmins =
                 userService.findTenantAdmins(savedTenant.getId(), pageLinkTenantAdmins);
-        Assert.assertFalse(tenantAdmins.hasNext());
         Assert.assertEquals(0, tenantAdmins.getTotalElements());
     }
 
-    private void assertEdgeIsDeleted(Tenant savedTenant, Edge savedEdge) {
-        Assert.assertNull(edgeService.findEdgeById(savedTenant.getId(), savedEdge.getId()));
-        PageLink pageLinkEdges = new PageLink(1000);
-        PageData<Edge> edges = edgeService.findEdgesByTenantId(savedTenant.getId(), pageLinkEdges);
-        Assert.assertFalse(edges.hasNext());
+    private void assertEdgeIsDeleted(Tenant tenant, Edge edge) {
+        assertThat(edgeService.findEdgeById(tenant.getId(), edge.getId()))
+                .as("edge").isNull();
+        PageLink pageLinkEdges = new PageLink(1);
+        PageData<Edge> edges = edgeService.findEdgesByTenantId(tenant.getId(), pageLinkEdges);
         Assert.assertEquals(0, edges.getTotalElements());
     }
 
-    private void assertDashboardIsDeleted(Tenant savedTenant, Dashboard savedDashboard) {
-        Assert.assertNull(dashboardService.findDashboardById(
-                savedTenant.getId(), savedDashboard.getId()
-        ));
-        PageLink pageLinkDashboards = new PageLink(1000);
+    private void assertDashboardIsDeleted(Tenant tenant, Dashboard dashboard) {
+        assertThat(dashboardService.findDashboardById(tenant.getId(), dashboard.getId()))
+                .as("dashboard").isNull();
+        PageLink pageLinkDashboards = new PageLink(1);
         PageData<DashboardInfo> dashboards =
-                dashboardService.findDashboardsByTenantId(savedTenant.getId(), pageLinkDashboards);
-        Assert.assertFalse(dashboards.hasNext());
+                dashboardService.findDashboardsByTenantId(tenant.getId(), pageLinkDashboards);
         Assert.assertEquals(0, dashboards.getTotalElements());
     }
 
-    private void assertDeviceProfileIsDeleted(Tenant savedTenant, DeviceProfile savedDeviceProfile) {
-        Assert.assertNull(deviceProfileService.findDeviceProfileById(
-                savedTenant.getId(), savedDeviceProfile.getId()
-        ));
-        PageLink pageLinkDeviceProfiles = new PageLink(1000);
+    private void assertDeviceProfileIsDeleted(Tenant tenant, DeviceProfile deviceProfile) {
+        assertThat(deviceProfileService.findDeviceProfileById(tenant.getId(), deviceProfile.getId()))
+                .as("deviceProfile").isNull();
+        PageLink pageLinkDeviceProfiles = new PageLink(1);
         PageData<DeviceProfile> profiles =
-                deviceProfileService.findDeviceProfiles(savedTenant.getId(), pageLinkDeviceProfiles);
-        Assert.assertFalse(profiles.hasNext());
+                deviceProfileService.findDeviceProfiles(tenant.getId(), pageLinkDeviceProfiles);
         Assert.assertEquals(0, profiles.getTotalElements());
     }
 
-    private void assertDeviceIsDeleted(Tenant savedTenant, Device savedDevice) {
-        Assert.assertNull(deviceService.findDeviceById(
-                savedTenant.getId(), savedDevice.getId()
-        ));
-        PageLink pageLinkDevices = new PageLink(1000);
+    private void assertDeviceIsDeleted(Tenant tenant, Device device) {
+        assertThat(deviceService.findDeviceById(tenant.getId(), device.getId()))
+                .as("device").isNull();
+        PageLink pageLinkDevices = new PageLink(1);
         PageData<Device> devices =
-                deviceService.findDevicesByTenantId(savedTenant.getId(), pageLinkDevices);
-        Assert.assertFalse(devices.hasNext());
+                deviceService.findDevicesByTenantId(tenant.getId(), pageLinkDevices);
         Assert.assertEquals(0, devices.getTotalElements());
     }
 
-    private void assertAssetIsDeleted(Tenant savedTenant, Asset savedAsset) {
-        Assert.assertNull(assetService.findAssetById(
-                savedTenant.getId(), savedAsset.getId()
-        ));
-        PageLink pageLinkAssets = new PageLink(1000);
+    private void assertAssetIsDeleted(Tenant tenant, Asset asset) {
+        assertThat(assetService.findAssetById(tenant.getId(), asset.getId()))
+                .as("asset").isNull();
+        PageLink pageLinkAssets = new PageLink(1);
         PageData<Asset> assets =
-                assetService.findAssetsByTenantId(savedTenant.getId(), pageLinkAssets);
-        Assert.assertFalse(assets.hasNext());
+                assetService.findAssetsByTenantId(tenant.getId(), pageLinkAssets);
         Assert.assertEquals(0, assets.getTotalElements());
     }
 
-    private void assertEntityViewIsDeleted(Tenant savedTenant, Device savedDevice, EntityView savedEntityView) {
-        Assert.assertNull(entityViewService.findEntityViewById(
-                savedTenant.getId(), savedEntityView.getId()
-        ));
+    private void assertEntityViewIsDeleted(Tenant tenant, Device device, EntityView entityView) {
+        assertThat(entityViewService.findEntityViewById(tenant.getId(), entityView.getId()))
+                .as("entityView").isNull();
         List<EntityView> entityViews =
-                entityViewService.findEntityViewsByTenantIdAndEntityId(
-                        savedTenant.getId(), savedDevice.getId());
+                entityViewService.findEntityViewsByTenantIdAndEntityId(tenant.getId(), device.getId());
         Assert.assertTrue(entityViews.isEmpty());
     }
 
-    private void assertWidgetsBundleIsDeleted(Tenant savedTenant, WidgetsBundle savedWidgetsBundle) {
-        Assert.assertNull(
-                widgetsBundleService.findWidgetsBundleById(savedTenant.getId(), savedWidgetsBundle.getId())
-        );
+    private void assertWidgetsBundleIsDeleted(Tenant tenant, WidgetsBundle widgetsBundle) {
+        assertThat(widgetsBundleService.findWidgetsBundleById(tenant.getId(), widgetsBundle.getId()))
+                .as("widgetBundle").isNull();
         List<WidgetsBundle> widgetsBundlesByTenantId =
-                widgetsBundleService.findAllTenantWidgetsBundlesByTenantId(savedTenant.getId());
+                widgetsBundleService.findAllTenantWidgetsBundlesByTenantId(tenant.getId());
         Assert.assertTrue(widgetsBundlesByTenantId.isEmpty());
     }
 
-    private void assertCustomerIsDeleted(Tenant savedTenant, Customer savedCustomer) {
-        Assert.assertNull(customerService.findCustomerById(savedTenant.getId(), savedCustomer.getId()));
-        PageLink pageLinkCustomer = new PageLink(1000);
+    private void assertCustomerIsDeleted(Tenant tenant, Customer customer) {
+        assertThat(customerService.findCustomerById(tenant.getId(), customer.getId()))
+                .as("customer").isNull();
+        PageLink pageLinkCustomer = new PageLink(1);
         PageData<Customer> pageDataCustomer = customerService
-                .findCustomersByTenantId(savedTenant.getId(), pageLinkCustomer);
-        Assert.assertFalse(pageDataCustomer.hasNext());
+                .findCustomersByTenantId(tenant.getId(), pageLinkCustomer);
         Assert.assertEquals(0, pageDataCustomer.getTotalElements());
     }
 
-    private Rpc createAndSaveRpcFor(Tenant savedTenant, Device savedDevice) {
+    private Rpc createAndSaveRpcFor(Tenant tenant, Device device) {
         Rpc rpc = new Rpc();
-        rpc.setTenantId(savedTenant.getId());
-        rpc.setDeviceId(savedDevice.getId());
+        rpc.setTenantId(tenant.getId());
+        rpc.setDeviceId(device.getId());
         rpc.setStatus(RpcStatus.QUEUED);
         rpc.setRequest(JacksonUtil.toJsonNode("{}"));
         return rpcService.save(rpc);
     }
 
-    private TbResource createAndSaveResourceFor(Tenant savedTenant) {
+    private TbResource createAndSaveResourceFor(Tenant tenant) {
         TbResource resource = new TbResource();
-        resource.setTenantId(savedTenant.getId());
+        resource.setTenantId(tenant.getId());
         resource.setTitle("Test resource");
         resource.setResourceType(ResourceType.LWM2M_MODEL);
         resource.setFileName("filename.txt");
@@ -567,47 +555,49 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         return resourceService.saveResource(resource);
     }
 
-    private OtaPackage createAndSaveOtaPackageFor(Tenant savedTenant, DeviceProfile savedDeviceProfile) {
-        OtaPackage otaPackage = createFirmware(savedTenant.getId(), savedDeviceProfile.getId());
-        return otaPackageService.saveOtaPackage(otaPackage);
+    private OtaPackage createAndSaveOtaPackageFor(Tenant tenant, DeviceProfile deviceProfile) {
+        return otaPackageService.saveOtaPackage(
+                BaseOtaPackageServiceTest.createFirmware(
+                        tenant.getId(), "2", deviceProfile.getId())
+        );
     }
 
-    private Edge createAndSaveEdgeFor(Tenant savedTenant) {
-        Edge edge = constructEdge(savedTenant.getId(), "Test edge", "Simple");
+    private Edge createAndSaveEdgeFor(Tenant tenant) {
+        Edge edge = constructEdge(tenant.getId(), "Test edge", "Simple");
         return edgeService.saveEdge(edge, false);
     }
 
-    private RuleChain createAndSaveRuleChainFor(Tenant savedTenant) {
+    private RuleChain createAndSaveRuleChainFor(Tenant tenant) {
         RuleChain ruleChain = new RuleChain();
-        ruleChain.setTenantId(savedTenant.getId());
+        ruleChain.setTenantId(tenant.getId());
         ruleChain.setName("Test rule chain");
         ruleChain.setType(RuleChainType.CORE);
         return ruleChainService.saveRuleChain(ruleChain);
     }
 
-    private Dashboard createAndSaveDashboardFor(Tenant savedTenant, Customer savedCustomer) {
+    private Dashboard createAndSaveDashboardFor(Tenant tenant, Customer customer) {
         Dashboard dashboard = new Dashboard();
-        dashboard.setTenantId(savedTenant.getId());
+        dashboard.setTenantId(tenant.getId());
         dashboard.setTitle("Test dashboard");
-        dashboard.setAssignedCustomers(Set.of(savedCustomer.toShortCustomerInfo()));
+        dashboard.setAssignedCustomers(Set.of(customer.toShortCustomerInfo()));
         return dashboardService.saveDashboard(dashboard);
     }
 
-    private Asset createAndSaveAssetFor(Tenant savedTenant, Customer savedCustomer) {
+    private Asset createAndSaveAssetFor(Tenant tenant, Customer customer) {
         Asset asset = new Asset();
-        asset.setTenantId(savedTenant.getId());
-        asset.setCustomerId(savedCustomer.getId());
+        asset.setTenantId(tenant.getId());
+        asset.setCustomerId(customer.getId());
         asset.setType("Test asset type");
         asset.setName("Test asset type");
         asset.setLabel("Test asset type");
         return assetService.saveAsset(asset);
     }
 
-    private EntityView createAndSaveEntityViewFor(Tenant savedTenant, Customer savedCustomer, Device savedDevice) {
+    private EntityView createAndSaveEntityViewFor(Tenant tenant, Customer customer, Device device) {
         EntityView entityView = new EntityView();
-        entityView.setEntityId(savedDevice.getId());
-        entityView.setTenantId(savedTenant.getId());
-        entityView.setCustomerId(savedCustomer.getId());
+        entityView.setEntityId(device.getId());
+        entityView.setTenantId(tenant.getId());
+        entityView.setCustomerId(customer.getId());
         entityView.setType("Test type");
         entityView.setName("Test entity view");
         entityView.setStartTimeMs(0);
@@ -615,20 +605,20 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         return entityViewService.saveEntityView(entityView);
     }
 
-    private Device createAndSaveDeviceFor(Tenant savedTenant, Customer savedCustomer, DeviceProfile savedDeviceProfile) {
+    private Device createAndSaveDeviceFor(Tenant tenant, Customer customer, DeviceProfile deviceProfile) {
         Device device = new Device();
-        device.setCustomerId(savedCustomer.getId());
-        device.setTenantId(savedTenant.getId());
+        device.setCustomerId(customer.getId());
+        device.setTenantId(tenant.getId());
         device.setType("Test type");
         device.setName("TestType");
         device.setLabel("Test type");
-        device.setDeviceProfileId(savedDeviceProfile.getId());
+        device.setDeviceProfileId(deviceProfile.getId());
         return deviceService.saveDevice(device);
     }
 
-    private DeviceProfile createAndSaveDeviceProfileWithProfileDataFor(Tenant savedTenant) {
+    private DeviceProfile createAndSaveDeviceProfileWithProfileDataFor(Tenant tenant) {
         DeviceProfile deviceProfile = new DeviceProfile();
-        deviceProfile.setTenantId(savedTenant.getId());
+        deviceProfile.setTenantId(tenant.getId());
         deviceProfile.setTransportType(DeviceTransportType.MQTT);
         deviceProfile.setName("Test device profile");
         deviceProfile.setType(DeviceProfileType.DEFAULT);
@@ -638,37 +628,37 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         return deviceProfileService.saveDeviceProfile(deviceProfile);
     }
 
-    private WidgetsBundle createAndSaveWidgetBundleFor(Tenant savedTenant) {
+    private WidgetsBundle createAndSaveWidgetBundleFor(Tenant tenant) {
         WidgetsBundle widgetsBundle = new WidgetsBundle();
-        widgetsBundle.setTenantId(savedTenant.getId());
+        widgetsBundle.setTenantId(tenant.getId());
         widgetsBundle.setTitle("Test widgets bundle");
         widgetsBundle.setAlias("TestWidgetsBundle");
         widgetsBundle.setDescription("Just a simple widgets bundle");
         return widgetsBundleService.saveWidgetsBundle(widgetsBundle);
     }
 
-    private Customer createAndSaveCustomerFor(Tenant savedTenant) {
+    private Customer createAndSaveCustomerFor(Tenant tenant) {
         Customer customer = new Customer();
         customer.setTitle("Test customer");
-        customer.setTenantId(savedTenant.getId());
+        customer.setTenantId(tenant.getId());
         customer.setEmail("testCustomer@test.com");
         return customerService.saveCustomer(customer);
     }
 
-    private User createAndSaveUserFor(Tenant savedTenant) {
+    private User createAndSaveUserFor(Tenant tenant) {
         User user = new User();
         user.setAuthority(Authority.TENANT_ADMIN);
         user.setEmail("tenantAdmin@test.com");
         user.setFirstName("tenantAdmin");
         user.setLastName("tenantAdmin");
-        user.setTenantId(savedTenant.getId());
+        user.setTenantId(tenant.getId());
         return userService.saveUser(user);
     }
 
-    private Tenant createAndSaveTenant(TenantProfile savedProfile) {
+    private Tenant createAndSaveTenant(TenantProfile tenantProfile) {
         Tenant tenant = new Tenant();
         tenant.setTitle("My tenant");
-        tenant.setTenantProfileId(savedProfile.getId());
+        tenant.setTenantProfileId(tenantProfile.getId());
         return tenantService.saveTenant(tenant);
     }
 
@@ -677,20 +667,4 @@ public abstract class BaseTenantServiceTest extends AbstractServiceTest {
         tenantProfile.setName("Test tenant profile");
         return tenantProfileService.saveTenantProfile(TenantId.SYS_TENANT_ID, tenantProfile);
     }
-
-    private OtaPackage createFirmware(TenantId tenantId, DeviceProfileId deviceProfileId) {
-        OtaPackage firmware = new OtaPackage();
-        firmware.setTenantId(tenantId);
-        firmware.setDeviceProfileId(deviceProfileId);
-        firmware.setType(FIRMWARE);
-        firmware.setTitle("My firmware");
-        firmware.setVersion("1");
-        firmware.setFileName("filename.txt");
-        firmware.setContentType("text/plain");
-        firmware.setChecksumAlgorithm(ChecksumAlgorithm.SHA256);
-        firmware.setChecksum("4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a");
-        firmware.setData(ByteBuffer.wrap(new byte[]{(int) 1L}));
-        firmware.setDataSize(1L);
-        return otaPackageService.saveOtaPackage(firmware);
-    }
 }

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbCreateRelationNode.java

@@ -124,7 +124,7 @@ public class TbCreateRelationNode extends TbAbstractRelationActionNode<TbCreateR
     }
 
     private ListenableFuture<Boolean> checkRelation(TbContext ctx, SearchDirectionIds sdId, String relationType) {
-        return ctx.getRelationService().checkRelation(ctx.getTenantId(), sdId.getFromId(), sdId.getToId(), relationType, RelationTypeGroup.COMMON);
+        return ctx.getRelationService().checkRelationAsync(ctx.getTenantId(), sdId.getFromId(), sdId.getToId(), relationType, RelationTypeGroup.COMMON);
     }
 
     private ListenableFuture<Boolean> processCreateRelation(TbContext ctx, EntityContainer entityContainer, SearchDirectionIds sdId, String relationType) {

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/action/TbDeleteRelationNode.java

@@ -98,7 +98,7 @@ public class TbDeleteRelationNode extends TbAbstractRelationActionNode<TbDeleteR
 
     private ListenableFuture<Boolean> processSingle(TbContext ctx, TbMsg msg, EntityContainer entityContainer, String relationType) {
         SearchDirectionIds sdId = processSingleSearchDirection(msg, entityContainer);
-        return Futures.transformAsync(ctx.getRelationService().checkRelation(ctx.getTenantId(), sdId.getFromId(), sdId.getToId(), relationType, RelationTypeGroup.COMMON),
+        return Futures.transformAsync(ctx.getRelationService().checkRelationAsync(ctx.getTenantId(), sdId.getFromId(), sdId.getToId(), relationType, RelationTypeGroup.COMMON),
                 result -> {
                     if (result) {
                         return processSingleDeleteRelation(ctx, sdId, relationType);

rule-engine/rule-engine-components/src/main/java/org/thingsboard/rule/engine/filter/TbCheckRelationNode.java

@@ -82,7 +82,7 @@ public class TbCheckRelationNode implements TbNode {
             to = EntityIdFactory.getByTypeAndId(config.getEntityType(), config.getEntityId());
             from = msg.getOriginator();
         }
-        return ctx.getRelationService().checkRelation(ctx.getTenantId(), from, to, config.getRelationType(), RelationTypeGroup.COMMON);
+        return ctx.getRelationService().checkRelationAsync(ctx.getTenantId(), from, to, config.getRelationType(), RelationTypeGroup.COMMON);
     }
 
     private ListenableFuture<Boolean> processList(TbContext ctx, TbMsg msg) {

rule-engine/rule-engine-components/src/test/java/org/thingsboard/rule/engine/action/TbCreateRelationNodeTest.java

@@ -113,7 +113,7 @@ public class TbCreateRelationNodeTest {
         metaData.putValue("type", "AssetType");
         msg = TbMsg.newMsg(DataConstants.ENTITY_CREATED, deviceId, metaData, TbMsgDataType.JSON, "{}", ruleChainId, ruleNodeId);
 
-        when(ctx.getRelationService().checkRelation(any(), eq(assetId), eq(deviceId), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
+        when(ctx.getRelationService().checkRelationAsync(any(), eq(assetId), eq(deviceId), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
                 .thenReturn(Futures.immediateFuture(false));
         when(ctx.getRelationService().saveRelationAsync(any(), eq(new EntityRelation(assetId, deviceId, RELATION_TYPE_CONTAINS, RelationTypeGroup.COMMON))))
                 .thenReturn(Futures.immediateFuture(true));
@@ -144,7 +144,7 @@ public class TbCreateRelationNodeTest {
         when(ctx.getRelationService().findByToAndTypeAsync(any(), eq(msg.getOriginator()), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
                 .thenReturn(Futures.immediateFuture(Collections.singletonList(relation)));
         when(ctx.getRelationService().deleteRelationAsync(any(), eq(relation))).thenReturn(Futures.immediateFuture(true));
-        when(ctx.getRelationService().checkRelation(any(), eq(assetId), eq(deviceId), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
+        when(ctx.getRelationService().checkRelationAsync(any(), eq(assetId), eq(deviceId), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
                 .thenReturn(Futures.immediateFuture(false));
         when(ctx.getRelationService().saveRelationAsync(any(), eq(new EntityRelation(assetId, deviceId, RELATION_TYPE_CONTAINS, RelationTypeGroup.COMMON))))
                 .thenReturn(Futures.immediateFuture(true));
@@ -171,7 +171,7 @@ public class TbCreateRelationNodeTest {
         metaData.putValue("type", "AssetType");
         msg = TbMsg.newMsg(DataConstants.ENTITY_CREATED, deviceId, metaData, TbMsgDataType.JSON, "{}", ruleChainId, ruleNodeId);
 
-        when(ctx.getRelationService().checkRelation(any(), eq(assetId), eq(deviceId), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
+        when(ctx.getRelationService().checkRelationAsync(any(), eq(assetId), eq(deviceId), eq(RELATION_TYPE_CONTAINS), eq(RelationTypeGroup.COMMON)))
                 .thenReturn(Futures.immediateFuture(false));
         when(ctx.getRelationService().saveRelationAsync(any(), eq(new EntityRelation(assetId, deviceId, RELATION_TYPE_CONTAINS, RelationTypeGroup.COMMON))))
                 .thenReturn(Futures.immediateFuture(true));