lwm2m: tests NoSec bootstrap update:

- connecting the client to the bootstrap server and updating the bootstrap
- client connection to lwm2m server, reboot when after executing "1/0/9" and update boostrap

application/src/test/java/org/thingsboard/server/transport/lwm2m/AbstractLwM2MIntegrationTest.java

@@ -273,6 +273,7 @@ public abstract class AbstractLwM2MIntegrationTest extends AbstractWebsocketTest
             "  }\n" +
             "}";
 
+     protected final Set<Lwm2mTestHelper.LwM2MClientState> expectedStatusesBsSuccess = new HashSet<>(Arrays.asList(ON_INIT, ON_BOOTSTRAP_STARTED, ON_BOOTSTRAP_SUCCESS));
      protected final Set<Lwm2mTestHelper.LwM2MClientState> expectedStatusesRegistrationLwm2mSuccess = new HashSet<>(Arrays.asList(ON_INIT, ON_REGISTRATION_STARTED, ON_REGISTRATION_SUCCESS));
     protected final Set<Lwm2mTestHelper.LwM2MClientState> expectedStatusesRegistrationBsSuccess = new HashSet<>(Arrays.asList(ON_INIT, ON_BOOTSTRAP_STARTED, ON_BOOTSTRAP_SUCCESS, ON_REGISTRATION_STARTED, ON_REGISTRATION_SUCCESS));
     protected DeviceProfile deviceProfile;
@@ -314,31 +315,6 @@ public abstract class AbstractLwM2MIntegrationTest extends AbstractWebsocketTest
         executor.shutdownNow();
     }
 
-    public void basicTestConnection(Security security,
-                                    LwM2MDeviceCredentials deviceCredentials,
-                                    Configuration coapConfig,
-                                    String endpoint,
-                                    Lwm2mDeviceProfileTransportConfiguration transportConfiguration,
-                                    String awaitAlias, Set<LwM2MClientState> expectedStatuses,
-                                    boolean isBootstrap, LwM2MSecurityMode mode) throws Exception {
-        createDeviceProfile(transportConfiguration);
-        createDevice(deviceCredentials, endpoint);
-        createNewClient(security, coapConfig, false, endpoint, isBootstrap);
-
-        await(awaitAlias)
-                .atMost(1000, TimeUnit.MILLISECONDS)
-                .until(() -> ON_REGISTRATION_SUCCESS.equals(client.getClientState()));
-        Assert.assertEquals(expectedStatuses, client.getClientStates());
-
-        client.destroy();
-        expectedStatuses.add(ON_DEREGISTRATION_STARTED);
-        expectedStatuses.add(ON_DEREGISTRATION_SUCCESS);
-        await(awaitAlias)
-                .atMost(1000, TimeUnit.MILLISECONDS)
-                .until(() -> ON_DEREGISTRATION_SUCCESS.equals(client.getClientState()));
-        Assert.assertEquals(expectedStatuses, client.getClientStates());
-    }
-
     public void basicTestConnectionObserveTelemetry(Security security,
                                                     LwM2MDeviceCredentials deviceCredentials,
                                                     Configuration coapConfig,
@@ -362,7 +338,7 @@ public abstract class AbstractLwM2MIntegrationTest extends AbstractWebsocketTest
         wsClient.waitForReply();
 
         wsClient.registerWaitForUpdate();
-        createNewClient(security, coapConfig, false, endpoint, false);
+        createNewClient(security, coapConfig, false, endpoint, false, null);
         String msg = wsClient.waitForUpdate();
 
         EntityDataUpdate update = mapper.readValue(msg, EntityDataUpdate.class);
@@ -422,11 +398,11 @@ public abstract class AbstractLwM2MIntegrationTest extends AbstractWebsocketTest
         this.resources = resources;
     }
 
-    public void createNewClient(Security security, Configuration coapConfig, boolean isRpc, String endpoint, boolean isBootstrap) throws Exception {
+    public void createNewClient(Security security, Configuration coapConfig, boolean isRpc, String endpoint, boolean isBootstrap, Security securityBs) throws Exception {
         clientDestroy();
         client = new LwM2MTestClient(this.executor, endpoint);
         int clientPort = SocketUtils.findAvailableTcpPort();
-        client.init(security, coapConfig, clientPort, isRpc, isBootstrap, this.shortServerId, this.shortServerIdBs);
+        client.init(security, coapConfig, clientPort, isRpc, isBootstrap, this.shortServerId, this.shortServerIdBs, securityBs);
     }
 
     private void clientDestroy() {

application/src/test/java/org/thingsboard/server/transport/lwm2m/Lwm2mTestHelper.java

@@ -51,6 +51,7 @@ public class Lwm2mTestHelper {
 
     // Ids in Client
     public static final int OBJECT_ID_0 = 0;
+    public static final int OBJECT_ID_1 = 1;
     public static final int OBJECT_INSTANCE_ID_0 = 0;
     public static final int OBJECT_INSTANCE_ID_1 = 1;
     public static final int OBJECT_INSTANCE_ID_2 = 2;

application/src/test/java/org/thingsboard/server/transport/lwm2m/client/LwM2MTestClient.java

@@ -26,6 +26,7 @@ import org.eclipse.leshan.client.object.Security;
 import org.eclipse.leshan.client.object.Server;
 import org.eclipse.leshan.client.observer.LwM2mClientObserver;
 import org.eclipse.leshan.client.resource.DummyInstanceEnabler;
+import org.eclipse.leshan.client.resource.LwM2mInstanceEnabler;
 import org.eclipse.leshan.client.resource.ObjectsInitializer;
 import org.eclipse.leshan.client.servers.ServerIdentity;
 import org.eclipse.leshan.core.ResponseCode;
@@ -103,7 +104,7 @@ public class LwM2MTestClient {
     private LwM2MClientState clientState;
     private Set<LwM2MClientState> clientStates;
 
-    public void init(Security security, Configuration coapConfig, int port, boolean isRpc, boolean isBootstrap, int shortServerId, int shortServerIdBs) throws InvalidDDFFileException, IOException {
+    public void init(Security security, Configuration coapConfig, int port, boolean isRpc, boolean isBootstrap, int shortServerId, int shortServerIdBs, Security securityBs) throws InvalidDDFFileException, IOException {
         Assert.assertNull("client already initialized", client);
         List<ObjectModel> models = new ArrayList<>();
         for (String resourceName : resources) {
@@ -111,11 +112,24 @@ public class LwM2MTestClient {
         }
         LwM2mModel model = new StaticModel(models);
         ObjectsInitializer initializer = new ObjectsInitializer(model);
-        initializer.setInstancesForObject(SECURITY, security);
+        if (securityBs == null) {
+            initializer.setInstancesForObject(SECURITY, security);
+        } else {
+            LwM2mInstanceEnabler[] instances = new LwM2mInstanceEnabler[]{securityBs, security};
+            initializer.setInstancesForObject(SECURITY, instances);
+        }
         if (isBootstrap) {
             initializer.setInstancesForObject(SERVER, lwm2mServer = new Server(shortServerIdBs, 300));
         } else {
-            initializer.setInstancesForObject(SERVER, lwm2mServer = new Server(shortServerId, 300));
+            if (securityBs == null) {
+                initializer.setInstancesForObject(SERVER, lwm2mServer = new Server(shortServerId, 300));
+            } else {
+                Server serverBootstrap = new Server(shortServerIdBs, 300);
+                Server serverLwm2m =  new Server(shortServerId, 300);
+                LwM2mInstanceEnabler[] instances = new LwM2mInstanceEnabler[]{serverBootstrap, serverLwm2m};
+                initializer.setClassForObject(SERVER, Server.class);
+                initializer.setInstancesForObject(SERVER, instances);
+            }
         }
         initializer.setInstancesForObject(DEVICE, lwM2MDevice = new SimpleLwM2MDevice());
         initializer.setInstancesForObject(FIRMWARE, fwLwM2MDevice = new FwLwM2MDevice());
@@ -245,7 +259,7 @@ public class LwM2MTestClient {
             public void onDeregistrationSuccess(ServerIdentity server, DeregisterRequest request) {
                 clientState = ON_DEREGISTRATION_SUCCESS;
                 clientStates.add(clientState);
-                log.info("ClientObserver ->onDeregistrationSuccess...  DeregisterRequest [{}]", request.getRegistrationId());
+//                log.info("ClientObserver ->onDeregistrationSuccess...  DeregisterRequest [{}]", request.getRegistrationId());
 
             }
 

application/src/test/java/org/thingsboard/server/transport/lwm2m/ota/sql/OtaLwM2MIntegrationTest.java

@@ -99,7 +99,7 @@ public class OtaLwM2MIntegrationTest extends AbstractOtaLwM2MIntegrationTest {
         createDeviceProfile(transportConfiguration);
         LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsNoSec(createNoSecClientCredentials(this.CLIENT_ENDPOINT_WITHOUT_FW_INFO));
         final Device device = createDevice(deviceCredentials, this.CLIENT_ENDPOINT_WITHOUT_FW_INFO);
-        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, false, this.CLIENT_ENDPOINT_WITHOUT_FW_INFO, false);
+        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, false, this.CLIENT_ENDPOINT_WITHOUT_FW_INFO, false, null);
 
         Thread.sleep(1000);
 
@@ -125,7 +125,7 @@ public class OtaLwM2MIntegrationTest extends AbstractOtaLwM2MIntegrationTest {
         createDeviceProfile(transportConfiguration);
         LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsNoSec(createNoSecClientCredentials(this.CLIENT_ENDPOINT_OTA5));
         final Device device = createDevice(deviceCredentials, this.CLIENT_ENDPOINT_OTA5);
-        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, false, this.CLIENT_ENDPOINT_OTA5, false);
+        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, false, this.CLIENT_ENDPOINT_OTA5, false, null);
 
         Thread.sleep(1000);
 
@@ -163,7 +163,7 @@ public class OtaLwM2MIntegrationTest extends AbstractOtaLwM2MIntegrationTest {
         createDeviceProfile(transportConfiguration);
         LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsNoSec(createNoSecClientCredentials(this.CLIENT_ENDPOINT_OTA9));
         final Device device = createDevice(deviceCredentials, this.CLIENT_ENDPOINT_OTA9);
-        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, false, this.CLIENT_ENDPOINT_OTA9, false);
+        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, false, this.CLIENT_ENDPOINT_OTA9, false, null);
 
         Thread.sleep(1000);
 

application/src/test/java/org/thingsboard/server/transport/lwm2m/rpc/AbstractRpcLwM2MIntegrationTest.java

@@ -79,7 +79,7 @@ public abstract class AbstractRpcLwM2MIntegrationTest extends AbstractLwM2MInteg
     public void beforeTest() throws Exception {
         String endpoint = DEVICE_ENDPOINT_RPC_PREF + endpointSequence.incrementAndGet();
         init();
-        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, true, endpoint, false);
+        createNewClient(SECURITY_NO_SEC, COAP_CONFIG, true, endpoint, false, null);
 
         expectedObjects = ConcurrentHashMap.newKeySet();
         expectedObjectIdVers = ConcurrentHashMap.newKeySet();

application/src/test/java/org/thingsboard/server/transport/lwm2m/security/AbstractSecurityLwM2MIntegrationTest.java

@@ -15,8 +15,12 @@
  */
 package org.thingsboard.server.transport.lwm2m.security;
 
+import com.fasterxml.jackson.databind.node.ObjectNode;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.codec.binary.Base64;
+import org.eclipse.californium.elements.config.Configuration;
+import org.eclipse.leshan.client.object.Security;
+import org.eclipse.leshan.core.ResponseCode;
 import org.junit.Assert;
 import org.springframework.test.web.servlet.MvcResult;
 import org.thingsboard.common.util.JacksonUtil;
@@ -30,6 +34,7 @@ import org.thingsboard.server.common.data.device.credentials.lwm2m.PSKBootstrapC
 import org.thingsboard.server.common.data.device.credentials.lwm2m.PSKClientCredential;
 import org.thingsboard.server.common.data.device.credentials.lwm2m.RPKBootstrapClientCredential;
 import org.thingsboard.server.common.data.device.credentials.lwm2m.X509BootstrapClientCredential;
+import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.common.data.device.profile.lwm2m.bootstrap.AbstractLwM2MBootstrapServerCredential;
 import org.thingsboard.server.common.data.device.profile.lwm2m.bootstrap.LwM2MBootstrapServerCredential;
 import org.thingsboard.server.common.data.device.profile.lwm2m.bootstrap.PSKLwM2MBootstrapServerCredential;
@@ -39,8 +44,8 @@ import org.thingsboard.server.common.data.security.DeviceCredentials;
 import org.thingsboard.server.common.data.security.DeviceCredentialsType;
 import org.thingsboard.server.dao.service.DaoSqlTest;
 import org.thingsboard.server.transport.lwm2m.AbstractLwM2MIntegrationTest;
+import org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState;
 import org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType;
-import org.thingsboard.server.transport.lwm2m.client.LwM2MTestClient;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -52,6 +57,20 @@ import java.security.cert.CertificateEncodingException;
 import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import static org.awaitility.Awaitility.await;
+import static org.eclipse.leshan.client.object.Security.noSec;
+import static org.eclipse.leshan.client.object.Security.noSecBootstap;
+import static org.junit.Assert.assertEquals;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_BOOTSTRAP_SUCCESS;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_DEREGISTRATION_STARTED;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_DEREGISTRATION_SUCCESS;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_REGISTRATION_SUCCESS;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.OBJECT_ID_1;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.RESOURCE_ID_9;
 
 @DaoSqlTest
 @Slf4j
@@ -74,7 +93,6 @@ public abstract class AbstractSecurityLwM2MIntegrationTest extends AbstractLwM2M
     protected final PublicKey serverPublicKeyFromCertBs;                                          // serverBs public key used for RPK
 
     // Client
-    protected LwM2MTestClient client;
     protected static final String CLIENT_ENDPOINT_NO_SEC = "LwNoSec00000000";
     protected static final String CLIENT_ENDPOINT_NO_SEC_BS = "LwNoSecBs00000000";
     protected static final String CLIENT_ENDPOINT_PSK = "LwPsk00000000";
@@ -144,6 +162,111 @@ public abstract class AbstractSecurityLwM2MIntegrationTest extends AbstractLwM2M
         defaultBootstrapCredentials.setLwm2mServer(serverCredentials);
     }
 
+    public void basicTestConnectionBefore(String clientEndpoint,
+                                          String awaitAlias,
+                                          LwM2MProfileBootstrapConfigType type,
+                                          Set<LwM2MClientState> expectedStatuses,
+                                          LwM2MClientState finishState) throws Exception {
+        Lwm2mDeviceProfileTransportConfiguration transportConfiguration = getTransportConfiguration(OBSERVE_ATTRIBUTES_WITHOUT_PARAMS, getBootstrapServerCredentialsNoSec(type));
+        LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsNoSec(createNoSecClientCredentials(clientEndpoint));
+        this.basicTestConnection(noSecBootstap(URI_BS),
+                deviceCredentials,
+                COAP_CONFIG_BS,
+                clientEndpoint,
+                transportConfiguration,
+                awaitAlias,
+                expectedStatuses,
+                true,
+                finishState);
+    }
+
+    protected void basicTestConnection(Security security,
+                                    LwM2MDeviceCredentials deviceCredentials,
+                                    Configuration coapConfig,
+                                    String endpoint,
+                                    Lwm2mDeviceProfileTransportConfiguration transportConfiguration,
+                                    String awaitAlias,
+                                    Set<LwM2MClientState> expectedStatuses,
+                                    boolean isBootstrap,
+                                    LwM2MClientState finishState) throws Exception {
+        createDeviceProfile(transportConfiguration);
+        createDevice(deviceCredentials, endpoint);
+        createNewClient(security, coapConfig, false, endpoint, isBootstrap, null);
+        await(awaitAlias)
+                .atMost(1000, TimeUnit.MILLISECONDS)
+                .until(() -> finishState.equals(client.getClientState()));
+        Assert.assertEquals(expectedStatuses, client.getClientStates());
+
+        client.destroy();
+        if (ON_BOOTSTRAP_SUCCESS != finishState) {
+            expectedStatuses.add(ON_DEREGISTRATION_STARTED);
+            expectedStatuses.add(ON_DEREGISTRATION_SUCCESS);
+            await(awaitAlias)
+                    .atMost(1000, TimeUnit.MILLISECONDS)
+                    .until(() -> ON_DEREGISTRATION_SUCCESS.equals(client.getClientState()));
+            Assert.assertEquals(expectedStatuses, client.getClientStates());
+        }
+    }
+
+
+
+    public void basicTestConnectionBootstrapRequestTriggerBefore(String clientEndpoint, String awaitAlias, LwM2MProfileBootstrapConfigType type) throws Exception {
+            Security securityBs = noSecBootstap(URI_BS);
+            Security security = noSec(URI, shortServerId);
+            Lwm2mDeviceProfileTransportConfiguration transportConfiguration = getTransportConfiguration(OBSERVE_ATTRIBUTES_WITHOUT_PARAMS, getBootstrapServerCredentialsNoSec(type));
+            LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsNoSec(createNoSecClientCredentials(clientEndpoint));
+            this.basicTestConnectionBootstrapRequestTrigger(
+                    security,
+                    deviceCredentials,
+                    COAP_CONFIG_BS,
+                    clientEndpoint,
+                    transportConfiguration,
+                    awaitAlias,
+                    expectedStatusesRegistrationLwm2mSuccess,
+                    expectedStatusesRegistrationBsSuccess,
+                    false,
+                    securityBs);
+
+    }
+
+    private void basicTestConnectionBootstrapRequestTrigger(Security security,
+                                                           LwM2MDeviceCredentials deviceCredentials,
+                                                           Configuration coapConfig,
+                                                           String endpoint,
+                                                           Lwm2mDeviceProfileTransportConfiguration transportConfiguration,
+                                                           String awaitAlias,
+                                                           Set<LwM2MClientState> expectedStatusesLwm2m,
+                                                           Set<LwM2MClientState> expectedStatusesBs,
+                                                           boolean isBootstrap,
+                                                           Security securityBs) throws Exception {
+        createDeviceProfile(transportConfiguration);
+        final Device device = createDevice(deviceCredentials, endpoint);
+        String deviceId = device.getId().getId().toString();
+        createNewClient(security, coapConfig, false, endpoint, isBootstrap, securityBs);
+
+        await(awaitAlias)
+                .atMost(1000, TimeUnit.MILLISECONDS)
+                .until(() -> ON_REGISTRATION_SUCCESS.equals(client.getClientState()));
+        Assert.assertEquals(expectedStatusesLwm2m, client.getClientStates());
+
+        String executedPath = getObjectIdVer_1() + "/0/" + RESOURCE_ID_9;
+        String actualResult = sendRPCExecuteById(executedPath, deviceId);
+        ObjectNode rpcActualResult = JacksonUtil.fromString(actualResult, ObjectNode.class);
+        assertEquals(ResponseCode.CHANGED.getName(), rpcActualResult.get("result").asText());
+
+        expectedStatusesBs.add(ON_DEREGISTRATION_STARTED);
+        expectedStatusesBs.add(ON_DEREGISTRATION_SUCCESS);
+        await(awaitAlias)
+                .atMost(1000, TimeUnit.MILLISECONDS)
+                .until(() -> ON_REGISTRATION_SUCCESS.equals(client.getClientState()));
+        Assert.assertEquals(expectedStatusesBs, client.getClientStates());
+
+        client.destroy();
+        await(awaitAlias)
+                .atMost(1000, TimeUnit.MILLISECONDS)
+                .until(() -> ON_DEREGISTRATION_SUCCESS.equals(client.getClientState()));
+        Assert.assertEquals(expectedStatusesBs, client.getClientStates());
+    }
 
     protected List<LwM2MBootstrapServerCredential> getBootstrapServerCredentialsSecure(LwM2MSecurityMode mode, LwM2MProfileBootstrapConfigType bootstrapConfigType) {
         List<LwM2MBootstrapServerCredential> bootstrap = new ArrayList<>();
@@ -280,4 +403,20 @@ public abstract class AbstractSecurityLwM2MIntegrationTest extends AbstractLwM2M
         deviceCredentials.setCredentialsValue(JacksonUtil.toString(credentials));
         return doPost("/api/device/credentials", deviceCredentials).andReturn();
     }
+
+    private String sendRPCExecuteById(String path, String deviceId) throws Exception {
+        String setRpcRequest = "{\"method\": \"Execute\", \"params\": {\"id\": \"" + path + "\"}}";
+        return doPostAsync("/api/plugins/rpc/twoway/" + deviceId, setRpcRequest, String.class, status().isOk());
+    }
+
+    private String getObjectIdVer_1() {
+        String ver_Id_0 = client.getClient().getObjectTree().getModel().getObjectModel(OBJECT_ID_1).version;
+        String objectIdVer_1;
+        if ("1.0".equals(ver_Id_0)) {
+            objectIdVer_1 = "/" + OBJECT_ID_1;
+        } else {
+            objectIdVer_1 = "/" + OBJECT_ID_1 + "_" + ver_Id_0;
+        }
+        return objectIdVer_1;
+    }
 }

application/src/test/java/org/thingsboard/server/transport/lwm2m/security/sql/NoSecLwM2MIntegrationTest.java

@@ -15,15 +15,16 @@
  */
 package org.thingsboard.server.transport.lwm2m.security.sql;
 
-import org.eclipse.leshan.client.object.Security;
 import org.junit.Test;
 import org.thingsboard.server.common.data.device.credentials.lwm2m.LwM2MDeviceCredentials;
-import org.thingsboard.server.common.data.device.profile.Lwm2mDeviceProfileTransportConfiguration;
 import org.thingsboard.server.transport.lwm2m.security.AbstractSecurityLwM2MIntegrationTest;
 
-import static org.eclipse.leshan.client.object.Security.noSecBootstap;
-import static org.thingsboard.server.common.data.device.credentials.lwm2m.LwM2MSecurityMode.NO_SEC;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_BOOTSTRAP_SUCCESS;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_REGISTRATION_SUCCESS;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.BOOTSTRAP_ONLY;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.BOTH;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.LWM2M_ONLY;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.NONE;
 
 public class NoSecLwM2MIntegrationTest extends AbstractSecurityLwM2MIntegrationTest {
 
@@ -39,17 +40,56 @@ public class NoSecLwM2MIntegrationTest extends AbstractSecurityLwM2MIntegrationT
     @Test
     public void testWithNoSecConnectBsSuccess_UpdateTwoSectionsBootstrapAndLm2m_ConnectLwm2mSuccess() throws Exception {
         String clientEndpoint = CLIENT_ENDPOINT_NO_SEC_BS;
-        Security securityBs = noSecBootstap(URI_BS);
-        Lwm2mDeviceProfileTransportConfiguration transportConfiguration = getTransportConfiguration(OBSERVE_ATTRIBUTES_WITHOUT_PARAMS, getBootstrapServerCredentialsNoSec(BOTH));
-        LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsNoSec(createNoSecClientCredentials(clientEndpoint));
-        this.basicTestConnection(securityBs,
-                deviceCredentials,
-                COAP_CONFIG_BS,
-                clientEndpoint,
-                transportConfiguration,
-                "await on client state (NoSecBS two section)",
-                expectedStatusesRegistrationBsSuccess,
-                true,
-                NO_SEC);
+        String awaitAlias = "await on client state (NoSecBS two section)";
+        basicTestConnectionBefore(clientEndpoint, awaitAlias, BOTH, expectedStatusesRegistrationBsSuccess, ON_REGISTRATION_SUCCESS);
+    }
+
+    @Test
+    public void testWithNoSecConnectBsSuccess_UpdateLwm2mSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC_BS + LWM2M_ONLY.name();
+        String awaitAlias = "await on client state (NoSecBS Lwm2m section)";
+        basicTestConnectionBefore(clientEndpoint, awaitAlias, LWM2M_ONLY, expectedStatusesRegistrationBsSuccess, ON_REGISTRATION_SUCCESS);
+    }
+
+    @Test
+    public void testWithNoSecConnectBsSuccess_UpdateBootstrapSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC + BOOTSTRAP_ONLY.name();
+        String awaitAlias = "await on client state (NoSecBS Bootstrap section)";
+        basicTestConnectionBefore(clientEndpoint, awaitAlias, BOOTSTRAP_ONLY, expectedStatusesBsSuccess, ON_BOOTSTRAP_SUCCESS);
+    }
+
+    @Test
+    public void testWithNoSecConnectBsSuccess_UpdateNoneSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC + NONE.name();
+        String awaitAlias = "await on client state (NoSecBS None section)";
+        basicTestConnectionBefore(clientEndpoint, awaitAlias, NONE, expectedStatusesBsSuccess, ON_BOOTSTRAP_SUCCESS);
+    }
+
+    @Test
+    public void testWithNoSecBootstrapRequestTriggerConnectBsSuccess_UpdateTwoSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC_BS + "Trigger" + BOTH.name();
+        String awaitAlias = "await on client state (NoSecBS Trigger Two section)";
+        basicTestConnectionBootstrapRequestTriggerBefore(clientEndpoint, awaitAlias, BOTH);
+    }
+
+    @Test
+    public void testWithNoSecBootstrapRequestTriggerConnectBsSuccess_UpdateBootstrapSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC_BS + "Trigger" + BOOTSTRAP_ONLY.name();
+        String awaitAlias = "await on client state (NoSecBS Trigger Bootstrap section)";
+        basicTestConnectionBootstrapRequestTriggerBefore(clientEndpoint, awaitAlias, BOOTSTRAP_ONLY);
+    }
+
+    @Test
+    public void testWithNoSecBootstrapRequestTriggerConnectBsSuccess_UpdateLwm2mSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC_BS + "Trigger" + LWM2M_ONLY.name();
+        String awaitAlias = "await on client state (NoSecBS Trigger Lwm2m section)";
+        basicTestConnectionBootstrapRequestTriggerBefore(clientEndpoint, awaitAlias, LWM2M_ONLY);
+    }
+
+    @Test
+    public void testWithNoSecBootstrapRequestTriggerConnectBsSuccess_UpdateNoneSectionAndLm2m_ConnectLwm2mSuccess() throws Exception {
+        String clientEndpoint = CLIENT_ENDPOINT_NO_SEC_BS + "Trigger" + NONE.name();
+        String awaitAlias = "await on client state (NoSecBS Trigger None  section)";
+        basicTestConnectionBootstrapRequestTriggerBefore(clientEndpoint, awaitAlias, NONE);
     }
 }

application/src/test/java/org/thingsboard/server/transport/lwm2m/security/sql/PskLwm2mIntegrationTest.java

@@ -32,6 +32,7 @@ import static org.eclipse.leshan.client.object.Security.pskBootstrap;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.thingsboard.server.common.data.device.credentials.lwm2m.LwM2MSecurityMode.PSK;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_REGISTRATION_SUCCESS;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.BOTH;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.NONE;
 
@@ -47,13 +48,13 @@ public class PskLwm2mIntegrationTest extends AbstractSecurityLwM2MIntegrationTes
         clientCredentials.setEndpoint(clientEndpoint);
         clientCredentials.setIdentity(identity);
         clientCredentials.setKey(keyPsk);
-        Security securityBs = psk(SECURE_URI,
+        Security security = psk(SECURE_URI,
                 shortServerId,
                 identity.getBytes(StandardCharsets.UTF_8),
                 Hex.decodeHex(keyPsk.toCharArray()));
         Lwm2mDeviceProfileTransportConfiguration transportConfiguration = getTransportConfiguration(OBSERVE_ATTRIBUTES_WITHOUT_PARAMS, getBootstrapServerCredentialsSecure(PSK, NONE));
         LwM2MDeviceCredentials deviceCredentials = getDeviceCredentialsSecure(clientCredentials, null, null, PSK);
-        this.basicTestConnection(securityBs,
+        this.basicTestConnection(security,
                 deviceCredentials,
                 COAP_CONFIG,
                 clientEndpoint,
@@ -61,7 +62,7 @@ public class PskLwm2mIntegrationTest extends AbstractSecurityLwM2MIntegrationTes
                 "await on client state (Psk_Lwm2m)",
                 expectedStatusesRegistrationLwm2mSuccess,
                 false,
-                PSK);
+                ON_REGISTRATION_SUCCESS);
     }
 
     @Test
@@ -106,6 +107,6 @@ public class PskLwm2mIntegrationTest extends AbstractSecurityLwM2MIntegrationTes
                 "await on client state (PskBS two section)",
                 expectedStatusesRegistrationBsSuccess,
                 true,
-                PSK);
+                ON_REGISTRATION_SUCCESS);
     }
 }

application/src/test/java/org/thingsboard/server/transport/lwm2m/security/sql/RpkLwM2MIntegrationTest.java

@@ -29,6 +29,7 @@ import java.security.cert.X509Certificate;
 import static org.eclipse.leshan.client.object.Security.rpk;
 import static org.eclipse.leshan.client.object.Security.rpkBootstrap;
 import static org.thingsboard.server.common.data.device.credentials.lwm2m.LwM2MSecurityMode.RPK;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_REGISTRATION_SUCCESS;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.BOTH;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.NONE;
 
@@ -58,7 +59,7 @@ public class RpkLwM2MIntegrationTest extends AbstractSecurityLwM2MIntegrationTes
                 "await on client state (Rpk_Lwm2m)",
                 expectedStatusesRegistrationLwm2mSuccess,
                 false,
-                RPK);
+                ON_REGISTRATION_SUCCESS);
     }
 
     // Bootstrap + Lwm2m
@@ -84,6 +85,6 @@ public class RpkLwM2MIntegrationTest extends AbstractSecurityLwM2MIntegrationTes
                 "await on client state (RpkBS two section)",
                 expectedStatusesRegistrationBsSuccess,
                 true,
-                RPK);
+                ON_REGISTRATION_SUCCESS);
     }
 }

application/src/test/java/org/thingsboard/server/transport/lwm2m/security/sql/X509_NoTrustLwM2MIntegrationTest.java

@@ -29,6 +29,7 @@ import java.security.cert.X509Certificate;
 import static org.eclipse.leshan.client.object.Security.x509;
 import static org.eclipse.leshan.client.object.Security.x509Bootstrap;
 import static org.thingsboard.server.common.data.device.credentials.lwm2m.LwM2MSecurityMode.X509;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_REGISTRATION_SUCCESS;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.BOTH;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.NONE;
 
@@ -58,7 +59,7 @@ public class X509_NoTrustLwM2MIntegrationTest extends AbstractSecurityLwM2MInteg
                 "await on client state (X509_Trust_Lwm2m)",
                 expectedStatusesRegistrationLwm2mSuccess,
                 false,
-                X509);
+                ON_REGISTRATION_SUCCESS);
     }
 
     // Bootstrap + Lwm2m
@@ -84,6 +85,6 @@ public class X509_NoTrustLwM2MIntegrationTest extends AbstractSecurityLwM2MInteg
                 "await on client state (X509NoTrust two section)",
                 expectedStatusesRegistrationBsSuccess,
                 true,
-                X509);
+                ON_REGISTRATION_SUCCESS);
     }
 }

application/src/test/java/org/thingsboard/server/transport/lwm2m/security/sql/X509_TrustLwM2MIntegrationTest.java

@@ -28,6 +28,7 @@ import java.security.cert.X509Certificate;
 import static org.eclipse.leshan.client.object.Security.x509;
 import static org.eclipse.leshan.client.object.Security.x509Bootstrap;
 import static org.thingsboard.server.common.data.device.credentials.lwm2m.LwM2MSecurityMode.X509;
+import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MClientState.ON_REGISTRATION_SUCCESS;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.BOTH;
 import static org.thingsboard.server.transport.lwm2m.Lwm2mTestHelper.LwM2MProfileBootstrapConfigType.NONE;
 
@@ -57,7 +58,7 @@ public class X509_TrustLwM2MIntegrationTest extends AbstractSecurityLwM2MIntegra
                 "await on client state (X509_Trust_Lwm2m)",
                 expectedStatusesRegistrationLwm2mSuccess,
                 false,
-                X509);
+                ON_REGISTRATION_SUCCESS);
     }
 
     // Bootstrap + Lwm2m
@@ -83,6 +84,6 @@ public class X509_TrustLwM2MIntegrationTest extends AbstractSecurityLwM2MIntegra
                 "await on client state (X509Trust two section)",
                 expectedStatusesRegistrationBsSuccess,
                 true,
-                X509);
+                ON_REGISTRATION_SUCCESS);
     }
 }