Base Edge test refactored into multiple independent tests

5 years ago · 8e91560f69
1 changed files with 155 additions and 221 deletions
--- a/application/src/test/java/org/thingsboard/server/edge/BaseEdgeTest.java
+++ b/application/src/test/java/org/thingsboard/server/edge/BaseEdgeTest.java
@ -34,6 +34,7 @@ import org.junit.Before;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.thingsboard.common.util.JacksonUtil;
+import org.thingsboard.server.cluster.TbClusterService;
 import org.thingsboard.server.common.data.Customer;
 import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.common.data.DataConstants;
@ -116,7 +117,6 @@ import org.thingsboard.server.gen.edge.v1.UserUpdateMsg;
 import org.thingsboard.server.gen.edge.v1.WidgetTypeUpdateMsg;
 import org.thingsboard.server.gen.edge.v1.WidgetsBundleUpdateMsg;
 import org.thingsboard.server.gen.transport.TransportProtos;
-import org.thingsboard.server.cluster.TbClusterService;

 import java.util.ArrayList;
 import java.util.List;
@ -165,7 +165,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        tenantAdmin.setLastName("Downs");

        tenantAdmin = createUserAndLogin(tenantAdmin, "testPassword1");
-        // sleep 1 seconds to avoid CREDENTIALS updated message for the user
+        // sleep 0.5 second to avoid CREDENTIALS updated message for the user
        // user credentials is going to be stored and updated event pushed to edge notification service
        // while service will be processing this event edge could be already added and additional message will be pushed
        Thread.sleep(500);
@ -176,7 +176,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        edgeImitator.expectMessageAmount(13);
        edgeImitator.connect();

-        testReceivedInitialData();
+        verifyEdgeConnectionAndInitialData();
    }

    @After
@ -187,41 +187,10 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        loginSysAdmin();

-        doDelete("/api/tenant/" + savedTenant.getId().getId().toString())
+        doDelete("/api/tenant/" + savedTenant.getUuidId())
                .andExpect(status().isOk());
    }

-    @Test
-    public void test() throws Exception {
-        testDevices();
-
-        testAssets();
-
-        testRuleChains();
-
-        testDashboards();
-
-        testRelations();
-
-        testAlarms();
-
-        testEntityView();
-
-        testCustomerAndNewUser();
-
-        testWidgetsBundleAndWidgetType();
-
-        testTimeseries();
-
-        testAttributes();
-
-        testRpcCall();
-
-        testTimeseriesWithFailures();
-
-        testSendMessagesToCloud();
-    }
-
    private void installation() throws Exception {
        edge = doPost("/api/edge", constructEdge("Test Edge", "test"), Edge.class);

@ -230,12 +199,12 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        doPost("/api/deviceProfile", deviceProfile, DeviceProfile.class);

        Device savedDevice = saveDevice("Edge Device 1", CUSTOM_DEVICE_PROFILE_NAME);
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/device/" + savedDevice.getId().getId().toString(), Device.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/device/" + savedDevice.getUuidId(), Device.class);

        Asset savedAsset = saveAsset("Edge Asset 1");
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/asset/" + savedAsset.getId().getId().toString(), Asset.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/asset/" + savedAsset.getUuidId(), Asset.class);
    }

    private void extendDeviceProfileData(DeviceProfile deviceProfile) {
@ -267,8 +236,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        profileData.setProvisionConfiguration(new AllowCreateNewDevicesDeviceProfileProvisionConfiguration("123"));
    }

-    private void testReceivedInitialData() throws Exception {
-        log.info("Checking received data");
+    private void verifyEdgeConnectionAndInitialData() throws Exception {
        Assert.assertTrue(edgeImitator.waitForMessages());

        EdgeConfiguration configuration = edgeImitator.getConfiguration();
@ -283,7 +251,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        UUID deviceUUID = new UUID(deviceUpdateMsg.getIdMSB(), deviceUpdateMsg.getIdLSB());
        Device device = doGet("/api/device/" + deviceUUID.toString(), Device.class);
        Assert.assertNotNull(device);
-        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/devices?",
+        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getUuidId() + "/devices?",
                new TypeReference<PageData<Device>>() {}, new PageLink(100)).getData();
        Assert.assertTrue(edgeDevices.contains(device));

@ -310,7 +278,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        UUID assetUUID = new UUID(assetUpdateMsg.getIdMSB(), assetUpdateMsg.getIdLSB());
        Asset asset = doGet("/api/asset/" + assetUUID.toString(), Asset.class);
        Assert.assertNotNull(asset);
-        List<Asset> edgeAssets = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/assets?",
+        List<Asset> edgeAssets = doGetTypedWithPageLink("/api/edge/" + edge.getUuidId() + "/assets?",
                new TypeReference<PageData<Asset>>() {}, new PageLink(100)).getData();
        Assert.assertTrue(edgeAssets.contains(asset));

@ -323,15 +291,13 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        UUID ruleChainUUID = new UUID(ruleChainUpdateMsg.getIdMSB(), ruleChainUpdateMsg.getIdLSB());
        RuleChain ruleChain = doGet("/api/ruleChain/" + ruleChainUUID.toString(), RuleChain.class);
        Assert.assertNotNull(ruleChain);
-        List<RuleChain> edgeRuleChains = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/ruleChains?",
+        List<RuleChain> edgeRuleChains = doGetTypedWithPageLink("/api/edge/" + edge.getUuidId() + "/ruleChains?",
                new TypeReference<PageData<RuleChain>>() {}, new PageLink(100)).getData();
        Assert.assertTrue(edgeRuleChains.contains(ruleChain));

        testAutoGeneratedCodeByProtobuf(ruleChainUpdateMsg);

        validateAdminSettings();
-
-        log.info("Received data checked");
    }

    private void validateAdminSettings() throws JsonProcessingException {
@ -367,39 +333,26 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertNotNull(jsonNode.get("test"));
    }

-    private void testDevices() throws Exception {
-        log.info("Testing devices");
-
+    @Test
+    public void testDevices() throws Exception {
        // 1
-        edgeImitator.expectMessageAmount(1);
-        Device savedDevice = saveDevice("Edge Device 2", "Default");
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/device/" + savedDevice.getId().getId().toString(), Device.class);
-        Assert.assertTrue(edgeImitator.waitForMessages());
-        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
-        Assert.assertTrue(latestMessage instanceof DeviceUpdateMsg);
-        DeviceUpdateMsg deviceUpdateMsg = (DeviceUpdateMsg) latestMessage;
-        Assert.assertEquals(UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE, deviceUpdateMsg.getMsgType());
-        Assert.assertEquals(deviceUpdateMsg.getIdMSB(), savedDevice.getUuidId().getMostSignificantBits());
-        Assert.assertEquals(deviceUpdateMsg.getIdLSB(), savedDevice.getUuidId().getLeastSignificantBits());
-        Assert.assertEquals(deviceUpdateMsg.getName(), savedDevice.getName());
-        Assert.assertEquals(deviceUpdateMsg.getType(), savedDevice.getType());
+        Device savedDevice = saveDeviceOnCloudAndVerifyDeliveryToEdge();

        // 2
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/edge/" + edge.getId().getId().toString()
-                + "/device/" + savedDevice.getId().getId().toString(), Device.class);
+        doDelete("/api/edge/" + edge.getUuidId()
+                + "/device/" + savedDevice.getUuidId(), Device.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
-        latestMessage = edgeImitator.getLatestMessage();
+        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof DeviceUpdateMsg);
-        deviceUpdateMsg = (DeviceUpdateMsg) latestMessage;
+        DeviceUpdateMsg deviceUpdateMsg = (DeviceUpdateMsg) latestMessage;
        Assert.assertEquals(UpdateMsgType.ENTITY_DELETED_RPC_MESSAGE, deviceUpdateMsg.getMsgType());
        Assert.assertEquals(deviceUpdateMsg.getIdMSB(), savedDevice.getUuidId().getMostSignificantBits());
        Assert.assertEquals(deviceUpdateMsg.getIdLSB(), savedDevice.getUuidId().getLeastSignificantBits());

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/device/" + savedDevice.getId().getId().toString())
+        doDelete("/api/device/" + savedDevice.getUuidId())
                .andExpect(status().isOk());
        // we should not get any message because device is not assigned to edge any more
        Assert.assertFalse(edgeImitator.waitForMessages(1));
@ -407,8 +360,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        // 4
        edgeImitator.expectMessageAmount(1);
        savedDevice = saveDevice("Edge Device 3", "Default");
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/device/" + savedDevice.getId().getId().toString(), Device.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/device/" + savedDevice.getUuidId(), Device.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof DeviceUpdateMsg);
@ -421,7 +374,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 5
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/device/" + savedDevice.getId().getId().toString())
+        doDelete("/api/device/" + savedDevice.getUuidId())
                .andExpect(status().isOk());
        // in this case we should get messages because device was assigned to edge
        Assert.assertTrue(edgeImitator.waitForMessages());
@ -432,17 +385,15 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(deviceUpdateMsg.getIdMSB(), savedDevice.getUuidId().getMostSignificantBits());
        Assert.assertEquals(deviceUpdateMsg.getIdLSB(), savedDevice.getUuidId().getLeastSignificantBits());

-        log.info("Devices tested successfully");
    }

-    private void testAssets() throws Exception {
-        log.info("Testing assets");
-
+    @Test
+    public void testAssets() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        Asset savedAsset = saveAsset("Edge Asset 2");
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/asset/" + savedAsset.getId().getId().toString(), Asset.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/asset/" + savedAsset.getUuidId(), Asset.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof AssetUpdateMsg);
@ -455,8 +406,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 2
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/edge/" + edge.getId().getId().toString()
-                + "/asset/" + savedAsset.getId().getId().toString(), Asset.class);
+        doDelete("/api/edge/" + edge.getUuidId()
+                + "/asset/" + savedAsset.getUuidId(), Asset.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof AssetUpdateMsg);
@ -467,15 +418,15 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/asset/" + savedAsset.getId().getId().toString())
+        doDelete("/api/asset/" + savedAsset.getUuidId())
                .andExpect(status().isOk());
        Assert.assertFalse(edgeImitator.waitForMessages(1));

        // 4
        edgeImitator.expectMessageAmount(1);
        savedAsset = saveAsset("Edge Asset 3");
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/asset/" + savedAsset.getId().getId().toString(), Asset.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/asset/" + savedAsset.getUuidId(), Asset.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof AssetUpdateMsg);
@ -488,7 +439,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 5
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/asset/" + savedAsset.getId().getId().toString())
+        doDelete("/api/asset/" + savedAsset.getUuidId())
                .andExpect(status().isOk());
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
@ -497,21 +448,18 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(UpdateMsgType.ENTITY_DELETED_RPC_MESSAGE, assetUpdateMsg.getMsgType());
        Assert.assertEquals(assetUpdateMsg.getIdMSB(), savedAsset.getUuidId().getMostSignificantBits());
        Assert.assertEquals(assetUpdateMsg.getIdLSB(), savedAsset.getUuidId().getLeastSignificantBits());
-
-        log.info("Assets tested successfully");
    }

-    private void testRuleChains() throws Exception {
-        log.info("Testing RuleChains");
-
+    @Test
+    public void testRuleChains() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(2);
        RuleChain ruleChain = new RuleChain();
        ruleChain.setName("Edge Test Rule Chain");
        ruleChain.setType(RuleChainType.EDGE);
        RuleChain savedRuleChain = doPost("/api/ruleChain", ruleChain, RuleChain.class);
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/ruleChain/" + savedRuleChain.getId().getId().toString(), RuleChain.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/ruleChain/" + savedRuleChain.getUuidId(), RuleChain.class);
        createRuleChainMetadata(savedRuleChain);
        Assert.assertTrue(edgeImitator.waitForMessages());
        Optional<RuleChainUpdateMsg> ruleChainUpdateMsgOpt = edgeImitator.findMessageByType(RuleChainUpdateMsg.class);
@ -528,8 +476,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/edge/" + edge.getId().getId().toString()
-                + "/ruleChain/" + savedRuleChain.getId().getId().toString(), RuleChain.class);
+        doDelete("/api/edge/" + edge.getUuidId()
+                + "/ruleChain/" + savedRuleChain.getUuidId(), RuleChain.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        ruleChainUpdateMsgOpt = edgeImitator.findMessageByType(RuleChainUpdateMsg.class);
        Assert.assertTrue(ruleChainUpdateMsgOpt.isPresent());
@ -540,11 +488,9 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 4
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/ruleChain/" + savedRuleChain.getId().getId().toString())
+        doDelete("/api/ruleChain/" + savedRuleChain.getUuidId())
                .andExpect(status().isOk());
        Assert.assertFalse(edgeImitator.waitForMessages(1));
-
-        log.info("RuleChains tested successfully");
    }

    private void testRuleChainMetadataRequestMsg(RuleChainId ruleChainId) throws Exception {
@ -608,16 +554,15 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        doPost("/api/ruleChain/metadata", ruleChainMetaData, RuleChainMetaData.class);
    }

-    private void testDashboards() throws Exception {
-        log.info("Testing Dashboards");
-
+    @Test
+    public void testDashboards() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        Dashboard dashboard = new Dashboard();
        dashboard.setTitle("Edge Test Dashboard");
        Dashboard savedDashboard = doPost("/api/dashboard", dashboard, Dashboard.class);
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/dashboard/" + savedDashboard.getId().getId().toString(), Dashboard.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/dashboard/" + savedDashboard.getUuidId(), Dashboard.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof DashboardUpdateMsg);
@ -641,8 +586,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/edge/" + edge.getId().getId().toString()
-                + "/dashboard/" + savedDashboard.getId().getId().toString(), Dashboard.class);
+        doDelete("/api/edge/" + edge.getUuidId()
+                + "/dashboard/" + savedDashboard.getUuidId(), Dashboard.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof DashboardUpdateMsg);
@ -653,16 +598,13 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 4
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/dashboard/" + savedDashboard.getId().getId().toString())
+        doDelete("/api/dashboard/" + savedDashboard.getUuidId())
                .andExpect(status().isOk());
        Assert.assertFalse(edgeImitator.waitForMessages(1));
-
-        log.info("Dashboards tested successfully");
    }

-    private void testRelations() throws Exception {
-        log.info("Testing Relations");
-
+    @Test
+    public void testRelations() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        Device device = findDeviceByName("Edge Device 1");
@ -710,13 +652,10 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(relationUpdateMsg.getToIdLSB(), relation.getTo().getId().getLeastSignificantBits());
        Assert.assertEquals(relationUpdateMsg.getToEntityType(), relation.getTo().getEntityType().name());
        Assert.assertEquals(relationUpdateMsg.getTypeGroup(), relation.getTypeGroup().name());
-
-        log.info("Relations tested successfully");
    }

-    private void testAlarms() throws Exception {
-        log.info("Testing Alarms");
-
+    @Test
+    public void testAlarms() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        Device device = findDeviceByName("Edge Device 1");
@ -739,7 +678,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 2
        edgeImitator.expectMessageAmount(1);
-        doPost("/api/alarm/" + savedAlarm.getId().getId().toString() + "/ack");
+        doPost("/api/alarm/" + savedAlarm.getUuidId() + "/ack");
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof AlarmUpdateMsg);
@ -752,7 +691,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doPost("/api/alarm/" + savedAlarm.getId().getId().toString() + "/clear");
+        doPost("/api/alarm/" + savedAlarm.getUuidId() + "/clear");
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof AlarmUpdateMsg);
@ -765,7 +704,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 4
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/alarm/" + savedAlarm.getId().getId().toString())
+        doDelete("/api/alarm/" + savedAlarm.getUuidId())
                .andExpect(status().isOk());
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
@ -776,13 +715,10 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(alarmUpdateMsg.getName(), savedAlarm.getName());
        Assert.assertEquals(alarmUpdateMsg.getOriginatorName(), device.getName());
        Assert.assertEquals(alarmUpdateMsg.getStatus(), AlarmStatus.CLEARED_ACK.name());
-
-        log.info("Alarms tested successfully");
    }

-    private void testEntityView() throws Exception {
-        log.info("Testing EntityView");
-
+    @Test
+    public void testEntityView() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        Device device = findDeviceByName("Edge Device 1");
@ -791,8 +727,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        entityView.setType("test");
        entityView.setEntityId(device.getId());
        EntityView savedEntityView = doPost("/api/entityView", entityView, EntityView.class);
-        doPost("/api/edge/" + edge.getId().getId().toString()
-                + "/entityView/" + savedEntityView.getId().getId().toString(), EntityView.class);
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/entityView/" + savedEntityView.getUuidId(), EntityView.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        verifyEntityViewUpdateMsg(savedEntityView, device);

@ -818,8 +754,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/edge/" + edge.getId().getId().toString()
-                + "/entityView/" + savedEntityView.getId().getId().toString(), EntityView.class);
+        doDelete("/api/edge/" + edge.getUuidId()
+                + "/entityView/" + savedEntityView.getUuidId(), EntityView.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof EntityViewUpdateMsg);
@ -830,11 +766,9 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {


        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/entityView/" + savedEntityView.getId().getId().toString())
+        doDelete("/api/entityView/" + savedEntityView.getUuidId())
                .andExpect(status().isOk());
        Assert.assertFalse(edgeImitator.waitForMessages(1));
-
-        log.info("EntityView tested successfully");
    }

    private void verifyEntityViewUpdateMsg(EntityView entityView, Device device) {
@ -851,16 +785,15 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(entityViewUpdateMsg.getEntityType().name(), device.getId().getEntityType().name());
    }

-    private void testCustomerAndNewUser() throws Exception {
-        log.info("Testing Customer");
-
+    @Test
+    public void testCustomerAndNewUser() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        Customer customer = new Customer();
        customer.setTitle("Edge Customer 1");
        Customer savedCustomer = doPost("/api/customer", customer, Customer.class);
-        doPost("/api/customer/" + savedCustomer.getId().getId().toString()
-                + "/edge/" + edge.getId().getId().toString(), Edge.class);
+        doPost("/api/customer/" + savedCustomer.getUuidId()
+                + "/edge/" + edge.getUuidId(), Edge.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof CustomerUpdateMsg);
@ -893,7 +826,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/customer/edge/" + edge.getId().getId().toString(), Edge.class);
+        doDelete("/api/customer/edge/" + edge.getUuidId(), Edge.class);
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
        Assert.assertTrue(latestMessage instanceof CustomerUpdateMsg);
@ -903,16 +836,13 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(customerUpdateMsg.getIdLSB(), savedCustomer.getUuidId().getLeastSignificantBits());

        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/customer/" + savedCustomer.getId().getId().toString())
+        doDelete("/api/customer/" + savedCustomer.getUuidId())
                .andExpect(status().isOk());
        Assert.assertFalse(edgeImitator.waitForMessages(1));
-
-        log.info("Customer tested successfully");
    }

-    private void testWidgetsBundleAndWidgetType() throws Exception {
-        log.info("Testing WidgetsBundle and WidgetType");
-
+    @Test
+    public void testWidgetsBundleAndWidgetType() throws Exception {
        // 1
        edgeImitator.expectMessageAmount(1);
        WidgetsBundle widgetsBundle = new WidgetsBundle();
@ -951,7 +881,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 3
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/widgetType/" + savedWidgetType.getId().getId().toString())
+        doDelete("/api/widgetType/" + savedWidgetType.getUuidId())
                .andExpect(status().isOk());
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
@ -963,7 +893,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        // 4
        edgeImitator.expectMessageAmount(1);
-        doDelete("/api/widgetsBundle/" + savedWidgetsBundle.getId().getId().toString())
+        doDelete("/api/widgetsBundle/" + savedWidgetsBundle.getUuidId())
                .andExpect(status().isOk());
        Assert.assertTrue(edgeImitator.waitForMessages());
        latestMessage = edgeImitator.getLatestMessage();
@ -972,13 +902,10 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(UpdateMsgType.ENTITY_DELETED_RPC_MESSAGE, widgetsBundleUpdateMsg.getMsgType());
        Assert.assertEquals(widgetsBundleUpdateMsg.getIdMSB(), savedWidgetsBundle.getUuidId().getMostSignificantBits());
        Assert.assertEquals(widgetsBundleUpdateMsg.getIdLSB(), savedWidgetsBundle.getUuidId().getLeastSignificantBits());
-
-        log.info("WidgetsBundle and WidgetType tested successfully");
    }

-    private void testTimeseries() throws Exception {
-        log.info("Testing timeseries");
-
+    @Test
+    public void testTimeseries() throws Exception {
        edgeImitator.expectMessageAmount(1);
        Device device = findDeviceByName("Edge Device 1");
        String timeseriesData = "{\"data\":{\"temperature\":25},\"ts\":" + System.currentTimeMillis() + "}";
@ -1004,18 +931,15 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        TransportProtos.KeyValueProto keyValueProto = tsKvListProto.getKv(0);
        Assert.assertEquals("temperature", keyValueProto.getKey());
        Assert.assertEquals(25, keyValueProto.getLongV());
-        log.info("Timeseries tested successfully");
    }

-    private void testAttributes() throws Exception {
-        log.info("Testing attributes");
+    @Test
+    public void testAttributes() throws Exception {
        Device device = findDeviceByName("Edge Device 1");

        testAttributesUpdatedMsg(device);
        testPostAttributesMsg(device);
        testAttributesDeleteMsg(device);
-
-        log.info("Attributes tested successfully");
    }

    private void testAttributesUpdatedMsg(Device device) throws JsonProcessingException, InterruptedException {
@ -1094,7 +1018,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals("key2", attributeDeleteMsg.getAttributeNames(1));
    }

-    private void testRpcCall() throws Exception {
+    @Test
+    public void testRpcCall() throws Exception {
        Device device = findDeviceByName("Edge Device 1");

        ObjectNode body = mapper.createObjectNode();
@ -1117,9 +1042,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals("test_method", latestDeviceRpcCallMsg.getRequestMsg().getMethod());
    }

-    private void testTimeseriesWithFailures() throws Exception {
-        log.info("Testing timeseries with failures");
-
+    @Test
+    public void testTimeseriesWithFailures() throws Exception {
        int numberOfTimeseriesToSend = 1000;

        edgeImitator.setRandomFailuresOnTimeseriesDownlink(true);
@ -1147,7 +1071,6 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        }

        edgeImitator.setRandomFailuresOnTimeseriesDownlink(false);
-        log.info("Timeseries with failures tested successfully");
    }

    private boolean isIdxExistsInTheDownlinkList(int idx, List<EntityDataProto> allTelemetryMsgs) {
@ -1165,25 +1088,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        return false;
    }

-    private void testSendMessagesToCloud() throws Exception {
-        log.info("Sending messages to cloud");
-        sendDevice();
-        sendDeviceWithNameThatAlreadyExistsOnCloud();
-        sendRelationRequest();
-        sendAlarm();
-        sendTelemetry();
-        sendRelation();
-        sendDeleteDeviceOnEdge();
-        sendRuleChainMetadataRequest();
-        sendUserCredentialsRequest();
-        sendDeviceCredentialsRequest();
-        sendDeviceRpcResponse();
-        sendDeviceCredentialsUpdate();
-        sendAttributesRequest();
-        log.info("Messages were sent successfully");
-    }
-
-    private void sendDevice() throws Exception {
+    @Test
+    public void testSendDeviceToCloud() throws Exception {
        UUID uuid = Uuids.timeBased();

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
@ -1218,7 +1124,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals("Edge Device 2", device.getName());
    }

-    private void sendDeviceWithNameThatAlreadyExistsOnCloud() throws Exception {
+    @Test
+    public void testSendDeviceToCloudWithNameThatAlreadyExistsOnCloud() throws Exception {
        String deviceOnCloudName = RandomStringUtils.randomAlphanumeric(15);
        Device deviceOnCloud = saveDevice(deviceOnCloudName, "Default");

@ -1270,7 +1177,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertNotEquals(deviceOnCloudName, device.getName());
    }

-    private void sendRelationRequest() throws Exception {
+    @Test
+    public void testSendRelationRequestToCloud() throws Exception {
        Device device = findDeviceByName("Edge Device 1");
        Asset asset = findAssetByName("Edge Asset 1");

@ -1317,8 +1225,9 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(relation.getTypeGroup().name(), relationUpdateMsg.getTypeGroup());
    }

-    private void sendAlarm() throws Exception {
-        Device device = findDeviceByName("Edge Device 2");
+    @Test
+    public void testSendAlarmToCloud() throws Exception {
+        Device device = saveDeviceOnCloudAndVerifyDeliveryToEdge();

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
        AlarmUpdateMsg.Builder alarmUpdateMgBuilder = AlarmUpdateMsg.newBuilder();
@ -1339,7 +1248,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {

        List<AlarmInfo> alarms = doGetTypedWithPageLink("/api/alarm/{entityType}/{entityId}?",
                new TypeReference<PageData<AlarmInfo>>() {},
-                new PageLink(100), device.getId().getEntityType().name(), device.getId().getId().toString())
+                new PageLink(100), device.getId().getEntityType().name(), device.getUuidId())
                .getData();
        Optional<AlarmInfo> foundAlarm = alarms.stream().filter(alarm -> alarm.getType().equals("alarm from edge")).findAny();
        Assert.assertTrue(foundAlarm.isPresent());
@ -1349,12 +1258,9 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(AlarmSeverity.CRITICAL, alarmInfo.getSeverity());
    }

-    private void sendTelemetry() throws Exception {
-        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/devices?",
-                new TypeReference<PageData<Device>>() {}, new PageLink(100)).getData();
-        Optional<Device> foundDevice = edgeDevices.stream().filter(device1 -> device1.getName().equals("Edge Device 2")).findAny();
-        Assert.assertTrue(foundDevice.isPresent());
-        Device device = foundDevice.get();
+    @Test
+    public void testSendTelemetryToCloud() throws Exception {
+        Device device = saveDeviceOnCloudAndVerifyDeliveryToEdge();

        edgeImitator.expectResponsesAmount(2);

@ -1402,7 +1308,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(1, timeseries.get(timeseriesKey).size());
        Assert.assertEquals(timeseriesValue, timeseries.get(timeseriesKey).get(0).get("value"));

-        List<Map<String, String>> attributes = doGetAsyncTyped("/api/plugins/telemetry/DEVICE/" + device.getId() + "/values/attributes/" + DataConstants.SERVER_SCOPE, new TypeReference<>() {});
+        String attributeValuesUrl = "/api/plugins/telemetry/DEVICE/" + device.getId() + "/values/attributes/" + DataConstants.SERVER_SCOPE;
+        List<Map<String, String>> attributes = doGetAsyncTyped(attributeValuesUrl, new TypeReference<>() {});
        Assert.assertEquals(2, attributes.size());
        var result = attributes.stream().filter(kv -> kv.get("key").equals(attributesKey)).filter(kv -> kv.get("value").equals(attributesValue)).findFirst();
        Assert.assertTrue(result.isPresent());
@ -1413,15 +1320,10 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
                new TypeReference<>() {});
    }

-    private void sendRelation() throws Exception {
-        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/devices?",
-                new TypeReference<PageData<Device>>() {}, new PageLink(100)).getData();
-        Optional<Device> foundDevice1 = edgeDevices.stream().filter(device1 -> device1.getName().equals("Edge Device 1")).findAny();
-        Assert.assertTrue(foundDevice1.isPresent());
-        Device device1 = foundDevice1.get();
-        Optional<Device> foundDevice2 = edgeDevices.stream().filter(device2 -> device2.getName().equals("Edge Device 2")).findAny();
-        Assert.assertTrue(foundDevice2.isPresent());
-        Device device2 = foundDevice2.get();
+    @Test
+    public void testSendRelationToCloud() throws Exception {
+        Device device1 = saveDeviceOnCloudAndVerifyDeliveryToEdge();
+        Device device2 = saveDeviceOnCloudAndVerifyDeliveryToEdge();

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
        RelationUpdateMsg.Builder relationUpdateMsgBuilder = RelationUpdateMsg.newBuilder();
@ -1444,17 +1346,18 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertTrue(edgeImitator.waitForResponses());

        EntityRelation relation = doGet("/api/relation?" +
-                "&fromId=" + device2.getId().getId().toString() +
+                "&fromId=" + device2.getUuidId() +
                "&fromType=" + device2.getId().getEntityType().name() +
                "&relationType=" + "test" +
                "&relationTypeGroup=" + RelationTypeGroup.COMMON.name() +
-                "&toId=" + device1.getId().getId().toString() +
+                "&toId=" + device1.getUuidId() +
                "&toType=" + device1.getId().getEntityType().name(), EntityRelation.class);
        Assert.assertNotNull(relation);
    }

-    private void sendDeleteDeviceOnEdge() throws Exception {
-        Device device = findDeviceByName("Edge Device 2");
+    @Test
+    public void testSendDeleteDeviceOnEdgeToCloud() throws Exception {
+        Device device = saveDeviceOnCloudAndVerifyDeliveryToEdge();
        UplinkMsg.Builder upLinkMsgBuilder = UplinkMsg.newBuilder();
        DeviceUpdateMsg.Builder deviceDeleteMsgBuilder = DeviceUpdateMsg.newBuilder();
        deviceDeleteMsgBuilder.setMsgType(UpdateMsgType.ENTITY_DELETED_RPC_MESSAGE);
@ -1468,15 +1371,16 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        edgeImitator.expectResponsesAmount(1);
        edgeImitator.sendUplinkMsg(upLinkMsgBuilder.build());
        Assert.assertTrue(edgeImitator.waitForResponses());
-        device = doGet("/api/device/" + device.getId().getId().toString(), Device.class);
+        device = doGet("/api/device/" + device.getUuidId(), Device.class);
        Assert.assertNotNull(device);
-        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/devices?",
+        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getUuidId() + "/devices?",
                new TypeReference<PageData<Device>>() {
                }, new PageLink(100)).getData();
        Assert.assertFalse(edgeDevices.contains(device));
    }

-    private void sendRuleChainMetadataRequest() throws Exception {
+    @Test
+    public void testSendRuleChainMetadataRequestToCloud() throws Exception {
        RuleChainId edgeRootRuleChainId = edge.getRootRuleChainId();

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
@ -1503,7 +1407,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        testAutoGeneratedCodeByProtobuf(ruleChainMetadataUpdateMsg);
    }

-    private void sendUserCredentialsRequest() throws Exception {
+    @Test
+    public void testSendUserCredentialsRequestToCloud() throws Exception {
        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
        UserCredentialsRequestMsg.Builder userCredentialsRequestMsgBuilder = UserCredentialsRequestMsg.newBuilder();
        userCredentialsRequestMsgBuilder.setUserIdMSB(tenantAdmin.getId().getId().getMostSignificantBits());
@ -1528,10 +1433,11 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        testAutoGeneratedCodeByProtobuf(userCredentialsUpdateMsg);
    }

-    private void sendDeviceCredentialsRequest() throws Exception {
+    @Test
+    public void testSendDeviceCredentialsRequestToCloud() throws Exception {
        Device device = findDeviceByName("Edge Device 1");

-        DeviceCredentials deviceCredentials = doGet("/api/device/" + device.getId().getId().toString() + "/credentials", DeviceCredentials.class);
+        DeviceCredentials deviceCredentials = doGet("/api/device/" + device.getUuidId() + "/credentials", DeviceCredentials.class);

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
        DeviceCredentialsRequestMsg.Builder deviceCredentialsRequestMsgBuilder = DeviceCredentialsRequestMsg.newBuilder();
@ -1557,7 +1463,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertEquals(deviceCredentialsUpdateMsg.getCredentialsId(), deviceCredentials.getCredentialsId());
    }

-    private void sendDeviceRpcResponse() throws Exception {
+    @Test
+    public void testSendDeviceRpcResponseToCloud() throws Exception {
        Device device = findDeviceByName("Edge Device 1");

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
@ -1582,7 +1489,8 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertTrue(edgeImitator.waitForResponses());
    }

-    private void sendDeviceCredentialsUpdate() throws Exception {
+    @Test
+    public void testSendDeviceCredentialsUpdateToCloud() throws Exception {
        Device device = findDeviceByName("Edge Device 1");

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
@ -1601,24 +1509,30 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertTrue(edgeImitator.waitForResponses());
    }

-    private void sendAttributesRequest() throws Exception {
+    @Test
+    public void testSendAttributesRequestToCloud() throws Exception {
        Device device = findDeviceByName("Edge Device 1");
-        sendAttributesRequest(device, DataConstants.SERVER_SCOPE, "{\"key1\":\"value1\"}",
-                "key1", "value1", 2);
-        sendAttributesRequest(device, DataConstants.SHARED_SCOPE, "{\"key2\":\"value2\"}",
-                "key2", "value2", 1);
+        sendAttributesRequestAndVerify(device, DataConstants.SERVER_SCOPE, "{\"key1\":\"value1\"}",
+                "key1", "value1");
+        sendAttributesRequestAndVerify(device, DataConstants.SHARED_SCOPE, "{\"key2\":\"value2\"}",
+                "key2", "value2");
    }

-    private void sendAttributesRequest(Device device, String scope, String attributesDataStr, String expectedKey,
-                                       String expectedValue, int expectedSize) throws Exception {
+    private void sendAttributesRequestAndVerify(Device device, String scope, String attributesDataStr, String expectedKey,
+                                                String expectedValue) throws Exception {
        JsonNode attributesData = mapper.readTree(attributesDataStr);

-        doPost("/api/plugins/telemetry/DEVICE/" + device.getId().getId().toString() + "/attributes/" + scope,
+        doPost("/api/plugins/telemetry/DEVICE/" + device.getUuidId() + "/attributes/" + scope,
                attributesData);

        // Wait before device attributes saved to database before requesting them from edge
-        // queue used to save attributes to database
-        Thread.sleep(500);
+        Awaitility.await()
+                .atMost(10, TimeUnit.SECONDS)
+                .until(() -> {
+                    String urlTemplate = "/api/plugins/telemetry/DEVICE/" + device.getId() + "/keys/attributes/" + scope;
+                    List<String> actualKeys = doGetAsyncTyped(urlTemplate, new TypeReference<>() {});
+                    return actualKeys != null && !actualKeys.isEmpty() && actualKeys.contains(expectedKey);
+                });

        UplinkMsg.Builder uplinkMsgBuilder = UplinkMsg.newBuilder();
        AttributesRequestMsg.Builder attributesRequestMsgBuilder = AttributesRequestMsg.newBuilder();
@ -1646,19 +1560,39 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
        Assert.assertTrue(latestEntityDataMsg.hasAttributesUpdatedMsg());

        TransportProtos.PostAttributeMsg attributesUpdatedMsg = latestEntityDataMsg.getAttributesUpdatedMsg();
-        Assert.assertEquals(expectedSize, attributesUpdatedMsg.getKvList().size());
+
+        boolean found = false;
        for (TransportProtos.KeyValueProto keyValueProto : attributesUpdatedMsg.getKvList()) {
            if (keyValueProto.getKey().equals(expectedKey)) {
                Assert.assertEquals(expectedKey, keyValueProto.getKey());
                Assert.assertEquals(expectedValue, keyValueProto.getStringV());
+                found = true;
            }
        }
+        Assert.assertTrue("Expected key and value must be found", found);
    }

    // Utility methods

+    private Device saveDeviceOnCloudAndVerifyDeliveryToEdge() throws Exception {
+        edgeImitator.expectMessageAmount(1);
+        Device savedDevice = saveDevice(RandomStringUtils.randomAlphanumeric(15), "Default");
+        doPost("/api/edge/" + edge.getUuidId()
+                + "/device/" + savedDevice.getUuidId(), Device.class);
+        Assert.assertTrue(edgeImitator.waitForMessages());
+        AbstractMessage latestMessage = edgeImitator.getLatestMessage();
+        Assert.assertTrue(latestMessage instanceof DeviceUpdateMsg);
+        DeviceUpdateMsg deviceUpdateMsg = (DeviceUpdateMsg) latestMessage;
+        Assert.assertEquals(UpdateMsgType.ENTITY_CREATED_RPC_MESSAGE, deviceUpdateMsg.getMsgType());
+        Assert.assertEquals(deviceUpdateMsg.getIdMSB(), savedDevice.getUuidId().getMostSignificantBits());
+        Assert.assertEquals(deviceUpdateMsg.getIdLSB(), savedDevice.getUuidId().getLeastSignificantBits());
+        Assert.assertEquals(deviceUpdateMsg.getName(), savedDevice.getName());
+        Assert.assertEquals(deviceUpdateMsg.getType(), savedDevice.getType());
+        return savedDevice;
+    }
+
    private Device findDeviceByName(String deviceName) throws Exception {
-        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/devices?",
+        List<Device> edgeDevices = doGetTypedWithPageLink("/api/edge/" + edge.getUuidId() + "/devices?",
                new TypeReference<PageData<Device>>() {
                }, new PageLink(100)).getData();
        Optional<Device> foundDevice = edgeDevices.stream().filter(d -> d.getName().equals(deviceName)).findAny();
@ -1669,7 +1603,7 @@ abstract public class BaseEdgeTest extends AbstractControllerTest {
    }

    private Asset findAssetByName(String assetName) throws Exception {
-        List<Asset> edgeAssets = doGetTypedWithPageLink("/api/edge/" + edge.getId().getId().toString() + "/assets?",
+        List<Asset> edgeAssets = doGetTypedWithPageLink("/api/edge/" + edge.getUuidId() + "/assets?",
                new TypeReference<PageData<Asset>>() {
                }, new PageLink(100)).getData();