Add support for Prepare, Review and Migrate pre-check in intermediary

Add support for Prepare, Review and Migrate pre-check
in ACM intermediary.

Issue-ID: POLICY-5080
Change-Id: I08045a8eb01dcea6492aac12b7a8021a47ae19e8
Signed-off-by: FrancescoFioraEst <francesco.fiora@est.tech>

5 files changed, 423 insertions, 59 deletions

diff --git a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AcSubStateHandlerTest.java b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AcSubStateHandlerTest.java
new file mode 100644
index 000000000..293a4415b
--- /dev/null
+++ b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AcSubStateHandlerTest.java
@@ -0,0 +1,164 @@
+/*-
+ * ============LICENSE_START=======================================================
+ *  Copyright (C) 2024 Nordix Foundation.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.clamp.acm.participant.intermediary.handler;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
+import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
+import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionMigration;
+import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionPrepare;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
+
+class AcSubStateHandlerTest {
+
+    @Test
+    void handleAcStateChangeNullTest() {
+        var cacheProvider = mock(CacheProvider.class);
+        var ach = new AcSubStateHandler(cacheProvider, mock(ThreadHandler.class));
+
+        var acMigration = new AutomationCompositionMigration();
+        acMigration.setPrecheck(true);
+        assertDoesNotThrow(() -> ach.handleAcMigrationPrecheck(acMigration));
+
+        var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
+        acMigration.setAutomationCompositionId(automationComposition.getInstanceId());
+        acMigration.setCompositionTargetId(UUID.randomUUID());
+        assertDoesNotThrow(() -> ach.handleAcMigrationPrecheck(acMigration));
+
+        var acPrepare = new AutomationCompositionPrepare();
+        assertDoesNotThrow(() -> ach.handleAcPrepare(acPrepare));
+
+        acPrepare.setAutomationCompositionId(automationComposition.getInstanceId());
+        assertDoesNotThrow(() -> ach.handleAcPrepare(acPrepare));
+    }
+
+    @Test
+    void handleAcMigrationPrecheckTest() {
+        var listener = mock(ThreadHandler.class);
+        var cacheProvider = mock(CacheProvider.class);
+        var ach = new AcSubStateHandler(cacheProvider, listener);
+        var migrationMsg = new AutomationCompositionMigration();
+        migrationMsg.setPrecheck(true);
+        assertDoesNotThrow(() -> ach.handleAcMigrationPrecheck(migrationMsg));
+        var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
+        migrationMsg.setCompositionTargetId(UUID.randomUUID());
+        migrationMsg.setAutomationCompositionId(automationComposition.getInstanceId());
+        assertDoesNotThrow(() -> ach.handleAcMigrationPrecheck(migrationMsg));
+        when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
+        var participantDeploy = new ParticipantDeploy();
+        participantDeploy.setParticipantId(CommonTestData.getParticipantId());
+        when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
+        migrationMsg.getParticipantUpdatesList().add(participantDeploy);
+        Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
+        for (var element : automationComposition.getElements().values()) {
+            var acElementDeploy = new AcElementDeploy();
+            acElementDeploy.setProperties(Map.of());
+            acElementDeploy.setId(element.getId());
+            acElementDeploy.setDefinition(element.getDefinition());
+            participantDeploy.getAcElementList().add(acElementDeploy);
+            map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
+        }
+        when(cacheProvider.getAcElementsDefinitions())
+                .thenReturn(Map.of(automationComposition.getCompositionId(), map,
+                        migrationMsg.getCompositionTargetId(), map));
+
+        ach.handleAcMigrationPrecheck(migrationMsg);
+        verify(listener, times(automationComposition.getElements().size()))
+                .migratePrecheck(any(), any(), any(), any(), any());
+    }
+
+    @Test
+    void handlePrepareTest() {
+        var listener = mock(ThreadHandler.class);
+        var cacheProvider = mock(CacheProvider.class);
+        var ach = new AcSubStateHandler(cacheProvider, listener);
+
+        var acPrepareMsg = new AutomationCompositionPrepare();
+        acPrepareMsg.setPreDeploy(true);
+        assertDoesNotThrow(() -> ach.handleAcPrepare(acPrepareMsg));
+
+        acPrepareMsg.setParticipantId(CommonTestData.getParticipantId());
+        when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
+        var participantDeploy = new ParticipantDeploy();
+        participantDeploy.setParticipantId(CommonTestData.getParticipantId());
+        acPrepareMsg.getParticipantList().add(participantDeploy);
+
+        var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
+        acPrepareMsg.setAutomationCompositionId(automationComposition.getInstanceId());
+        when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
+        Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
+        for (var element : automationComposition.getElements().values()) {
+            var acElementDeploy = new AcElementDeploy();
+            acElementDeploy.setProperties(Map.of());
+            acElementDeploy.setId(element.getId());
+            participantDeploy.getAcElementList().add(acElementDeploy);
+            map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
+        }
+        when(cacheProvider.getAcElementsDefinitions())
+            .thenReturn(Map.of(automationComposition.getCompositionId(), map));
+
+        ach.handleAcPrepare(acPrepareMsg);
+        verify(listener, times(automationComposition.getElements().size())).prepare(any(), any(), any());
+    }
+
+    @Test
+    void handleReviewTest() {
+        var cacheProvider = mock(CacheProvider.class);
+        when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
+
+        var acPrepareMsg = new AutomationCompositionPrepare();
+        acPrepareMsg.setPreDeploy(false);
+        acPrepareMsg.setParticipantId(CommonTestData.getParticipantId());
+
+        var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
+        acPrepareMsg.setAutomationCompositionId(automationComposition.getInstanceId());
+        when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
+            .thenReturn(automationComposition);
+        Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
+        for (var element : automationComposition.getElements().values()) {
+            var acElementDeploy = new AcElementDeploy();
+            acElementDeploy.setProperties(Map.of());
+            acElementDeploy.setId(element.getId());
+            map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
+        }
+        when(cacheProvider.getAcElementsDefinitions())
+            .thenReturn(Map.of(automationComposition.getCompositionId(), map));
+
+        var listener = mock(ThreadHandler.class);
+        var ach = new AcSubStateHandler(cacheProvider, listener);
+        ach.handleAcPrepare(acPrepareMsg);
+        verify(listener, times(automationComposition.getElements().size())).review(any(), any(), any());
+    }
+}
diff --git a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionOutHandlerTest.java b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionOutHandlerTest.java
index eed5319f8..27813988d 100644
--- a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionOutHandlerTest.java
+++ b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/AutomationCompositionOutHandlerTest.java
@@ -39,6 +39,7 @@ import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDef
 import org.onap.policy.clamp.models.acm.concepts.DeployState;
 import org.onap.policy.clamp.models.acm.concepts.LockState;
 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
+import org.onap.policy.clamp.models.acm.concepts.SubState;
 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeployAck;
 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrimeAck;
 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
@@ -87,6 +88,23 @@ class AutomationCompositionOutHandlerTest {
     }
 
     @Test
+    void updateAutomationCompositionElementStatePrepareTest() {
+        var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
+        automationComposition.setSubState(SubState.PREPARING);
+        var cacheProvider = mock(CacheProvider.class);
+        when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
+                .thenReturn(automationComposition);
+        var element = automationComposition.getElements().values().iterator().next();
+        element.setSubState(SubState.PREPARING);
+        var elementId = element.getId();
+        var publisher = mock(ParticipantMessagePublisher.class);
+        var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
+        acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId,
+                DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Prepare completed");
+        verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
+    }
+
+    @Test
     void updateAutomationCompositionElementStateLockTest() {
         var publisher = mock(ParticipantMessagePublisher.class);
         var cacheProvider = mock(CacheProvider.class);
diff --git a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/CacheProviderTest.java b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/CacheProviderTest.java
index 9451f0138..ced2d81e8 100644
--- a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/CacheProviderTest.java
+++ b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/CacheProviderTest.java
@@ -186,4 +186,36 @@ class CacheProviderTest {
             assertEquals(element.getDefinition(), result.elementDefinitionId());
         }
     }
+
+    @Test
+    void testGetCompositionElementDtoMap() {
+        var parameter = CommonTestData.getParticipantParameters();
+        var cacheProvider = new CacheProvider(parameter);
+        var compositionId = UUID.randomUUID();
+        var automationComposition =
+                CommonTestData.getTestAutomationCompositions().getAutomationCompositionList().get(0);
+        automationComposition.setCompositionId(compositionId);
+        cacheProvider.addElementDefinition(compositionId,
+                CommonTestData.createAutomationCompositionElementDefinitionList(automationComposition));
+        var result = cacheProvider.getCompositionElementDtoMap(automationComposition);
+        for (var element : automationComposition.getElements().values()) {
+            var compositionElementDto = result.get(element.getId());
+            assertEquals(element.getDefinition(), compositionElementDto.elementDefinitionId());
+        }
+    }
+
+    @Test
+    void testGetInstanceElementDtoMap() {
+        var parameter = CommonTestData.getParticipantParameters();
+        var cacheProvider = new CacheProvider(parameter);
+        var compositionId = UUID.randomUUID();
+        var automationComposition =
+                CommonTestData.getTestAutomationCompositions().getAutomationCompositionList().get(0);
+        automationComposition.setCompositionId(compositionId);
+        var result = cacheProvider.getInstanceElementDtoMap(automationComposition);
+        for (var element : automationComposition.getElements().values()) {
+            var compositionElementDto = result.get(element.getId());
+            assertEquals(element.getId(), compositionElementDto.elementId());
+        }
+    }
 }
diff --git a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandlerTest.java b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandlerTest.java
index 8c2b2473c..1fb72812b 100644
--- a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandlerTest.java
+++ b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ParticipantHandlerTest.java
@@ -62,7 +62,8 @@ class ParticipantHandlerTest {
         when(publisher.isActive()).thenReturn(true);
         var cacheProvider = mock(CacheProvider.class);
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), mock(AcDefinitionHandler.class), publisher, cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
+            publisher, cacheProvider);
         participantHandler.handleParticipantStatusReq(new ParticipantStatusReq());
         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
 
@@ -76,7 +77,8 @@ class ParticipantHandlerTest {
     void handleAutomationCompositionDeployTest() {
         var acHandler = mock(AutomationCompositionHandler.class);
         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
-                mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
+            mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
+            mock(CacheProvider.class));
         var automationCompositionDeploy = new AutomationCompositionDeploy();
         participantHandler.handleAutomationCompositionDeploy(automationCompositionDeploy);
         verify(acHandler).handleAutomationCompositionDeploy(automationCompositionDeploy);
@@ -86,8 +88,8 @@ class ParticipantHandlerTest {
     void handleAutomationCompositionStateChangeTest() {
         var acHandler = mock(AutomationCompositionHandler.class);
         var acLockHandler = mock(AcLockHandler.class);
-        var participantHandler = new ParticipantHandler(acHandler, acLockHandler, mock(AcDefinitionHandler.class),
-                mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
+        var participantHandler = new ParticipantHandler(acHandler, acLockHandler, mock(AcSubStateHandler.class),
+            mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
         var acStateChange = new AutomationCompositionStateChange();
 
         acStateChange.setDeployOrderedState(DeployOrder.DEPLOY);
@@ -104,18 +106,25 @@ class ParticipantHandlerTest {
     @Test
     void handleAutomationCompositionMigrationTest() {
         var acHandler = mock(AutomationCompositionHandler.class);
+        var acSubStateHandler = mock(AcSubStateHandler.class);
         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
-                mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
+            acSubStateHandler, mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
+            mock(CacheProvider.class));
         var migrationMsg = new AutomationCompositionMigration();
         participantHandler.handleAutomationCompositionMigration(migrationMsg);
         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
+
+        migrationMsg.setPrecheck(true);
+        participantHandler.handleAutomationCompositionMigration(migrationMsg);
+        verify(acSubStateHandler).handleAcMigrationPrecheck(migrationMsg);
     }
 
     @Test
     void handleAcPropertyUpdateTest() {
         var acHandler = mock(AutomationCompositionHandler.class);
         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
-                mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
+            mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
+            mock(CacheProvider.class));
         var propertyUpdateMsg = new PropertiesUpdate();
         participantHandler.handleAcPropertyUpdate(propertyUpdateMsg);
         verify(acHandler).handleAcPropertyUpdate(propertyUpdateMsg);
@@ -127,8 +136,8 @@ class ParticipantHandlerTest {
         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
         when(cacheProvider.getReplicaId()).thenReturn(CommonTestData.getReplicaId());
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
-                cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
+            mock(ParticipantMessagePublisher.class), cacheProvider);
 
         var participantAckMsg = new ParticipantAckMessage(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
         assertTrue(participantHandler.appliesTo(participantAckMsg));
@@ -147,7 +156,8 @@ class ParticipantHandlerTest {
         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
         when(cacheProvider.getSupportedAcElementTypes()).thenReturn(List.of(new ParticipantSupportedElementType()));
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), mock(AcDefinitionHandler.class), publisher, cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
+            cacheProvider);
 
         participantHandler.sendParticipantRegister();
         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
@@ -159,7 +169,8 @@ class ParticipantHandlerTest {
         var cacheProvider = mock(CacheProvider.class);
         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), mock(AcDefinitionHandler.class), publisher, cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
+            cacheProvider);
 
         participantHandler.handleParticipantRegisterAck(new ParticipantRegisterAck());
         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
@@ -171,7 +182,8 @@ class ParticipantHandlerTest {
         var cacheProvider = mock(CacheProvider.class);
         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), mock(AcDefinitionHandler.class), publisher, cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
+            cacheProvider);
 
         participantHandler.sendParticipantDeregister();
         verify(publisher).sendParticipantDeregister(any(ParticipantDeregister.class));
@@ -180,8 +192,8 @@ class ParticipantHandlerTest {
     @Test
     void handleParticipantDeregisterAckTest() {
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
-                mock(CacheProvider.class));
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
+            mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
         var participantDeregisterAck = new ParticipantDeregisterAck();
         assertDoesNotThrow(() -> participantHandler.handleParticipantDeregisterAck(participantDeregisterAck));
     }
@@ -194,8 +206,8 @@ class ParticipantHandlerTest {
 
         var acHandler = mock(AcDefinitionHandler.class);
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), acHandler, mock(ParticipantMessagePublisher.class),
-                mock(CacheProvider.class));
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler,
+            mock(ParticipantMessagePublisher.class), mock(CacheProvider.class));
 
         participantHandler.handleParticipantPrime(participantPrime);
         verify(acHandler).handlePrime(participantPrime);
@@ -213,7 +225,7 @@ class ParticipantHandlerTest {
         var publisher = mock(ParticipantMessagePublisher.class);
         var acHandler = mock(AcDefinitionHandler.class);
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), acHandler, publisher, cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler, publisher, cacheProvider);
 
         participantHandler.handleParticipantSync(participantSyncMsg);
         verify(acHandler).handleParticipantSync(participantSyncMsg);
@@ -229,7 +241,7 @@ class ParticipantHandlerTest {
         when(publisher.isActive()).thenReturn(true);
         var acHandler = mock(AcDefinitionHandler.class);
         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
-                mock(AcLockHandler.class), acHandler, publisher, cacheProvider);
+            mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler, publisher, cacheProvider);
         participantHandler.sendHeartbeat();
         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
 
diff --git a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ThreadHandlerTest.java b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ThreadHandlerTest.java
index f3471e6ee..57b065978 100644
--- a/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ThreadHandlerTest.java
+++ b/participant/participant-intermediary/src/test/java/org/onap/policy/clamp/acm/participant/intermediary/handler/ThreadHandlerTest.java
@@ -49,7 +49,7 @@ class ThreadHandlerTest {
     private static final int TIMEOUT = 400;
 
     @Test
-    void test() throws PfModelException, IOException {
+    void testPrime() throws PfModelException, IOException {
         var listener = mock(AutomationCompositionElementListener.class);
         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
         try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
@@ -61,11 +61,45 @@ class ThreadHandlerTest {
             verify(listener, timeout(TIMEOUT)).prime(composition);
 
             clearInvocations(listener);
+            threadHandler.deprime(messageId, composition);
+            verify(listener, timeout(TIMEOUT)).deprime(composition);
+        }
+    }
+
+    @Test
+    void testPrimeException() throws PfModelException, IOException {
+        var listener = mock(AutomationCompositionElementListener.class);
+        var intermediaryApi = mock(ParticipantIntermediaryApi.class);
+        try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
+
+            var compositionId = UUID.randomUUID();
+            var composition = new CompositionDto(compositionId, Map.of(), Map.of());
+            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).prime(composition);
+            var messageId = UUID.randomUUID();
+            threadHandler.prime(messageId, composition);
+            verify(intermediaryApi, timeout(TIMEOUT)).updateCompositionState(compositionId, AcTypeState.COMMISSIONED,
+                StateChangeResult.FAILED, "Composition Defintion prime failed");
+
+            clearInvocations(listener);
+            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).deprime(composition);
+            threadHandler.deprime(messageId, composition);
+            verify(intermediaryApi, timeout(TIMEOUT)).updateCompositionState(compositionId, AcTypeState.PRIMED,
+                StateChangeResult.FAILED, "Composition Defintion deprime failed");
+        }
+    }
+
+    @Test
+    void testDeploy() throws PfModelException, IOException {
+        var listener = mock(AutomationCompositionElementListener.class);
+        var intermediaryApi = mock(ParticipantIntermediaryApi.class);
+        try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
+
             Map<String, Object> properties = Map.of("key", "value");
             var compositionElement = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
                 properties, properties);
             var instanceElement = new InstanceElementDto(UUID.randomUUID(), UUID.randomUUID(),
-                null, properties, properties);
+                    null, properties, properties);
+            var messageId = UUID.randomUUID();
             threadHandler.deploy(messageId, compositionElement, instanceElement);
             verify(listener, timeout(TIMEOUT)).deploy(compositionElement, instanceElement);
 
@@ -88,43 +122,21 @@ class ThreadHandlerTest {
                 instanceElement, instanceElementUpdated);
 
             clearInvocations(listener);
-            threadHandler.lock(messageId, compositionElement, instanceElement);
-            verify(listener, timeout(TIMEOUT)).lock(compositionElement, instanceElement);
-
-            clearInvocations(listener);
-            threadHandler.unlock(messageId, compositionElement, instanceElement);
-            verify(listener, timeout(TIMEOUT)).unlock(compositionElement, instanceElement);
-
-            clearInvocations(listener);
             threadHandler.undeploy(messageId, compositionElement, instanceElement);
             verify(listener, timeout(TIMEOUT)).undeploy(compositionElement, instanceElement);
 
             clearInvocations(listener);
             threadHandler.delete(messageId, compositionElement, instanceElement);
             verify(listener, timeout(TIMEOUT)).delete(compositionElement, instanceElement);
-
-            clearInvocations(listener);
-            threadHandler.deprime(messageId, composition);
-            verify(listener, timeout(TIMEOUT)).deprime(composition);
         }
     }
 
     @Test
-    void testException() throws PfModelException, IOException {
+    void testDeployException() throws PfModelException, IOException {
         var listener = mock(AutomationCompositionElementListener.class);
         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
         try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
 
-            var compositionId = UUID.randomUUID();
-            var composition = new CompositionDto(compositionId, Map.of(), Map.of());
-            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
-                .prime(composition);
-            var messageId = UUID.randomUUID();
-            threadHandler.prime(messageId, composition);
-            verify(intermediaryApi, timeout(TIMEOUT)).updateCompositionState(compositionId, AcTypeState.COMMISSIONED,
-                    StateChangeResult.FAILED, "Composition Defintion prime failed");
-
-            clearInvocations(intermediaryApi);
             Map<String, Object> properties = Map.of("key", "value");
             var compositionElement = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
                 properties, properties);
@@ -135,9 +147,10 @@ class ThreadHandlerTest {
             element.setId(elementId);
             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
                 .deploy(compositionElement, instanceElement);
+            var messageId = UUID.randomUUID();
             threadHandler.deploy(messageId, compositionElement, instanceElement);
             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
-                    DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
+                DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
                     "Automation composition element deploy failed");
 
             clearInvocations(listener);
@@ -147,44 +160,169 @@ class ThreadHandlerTest {
                 .update(compositionElement, instanceElement, instanceElementUpdated);
             threadHandler.update(messageId, compositionElement, instanceElement, instanceElementUpdated);
             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
-                    DeployState.DEPLOYED, null, StateChangeResult.FAILED,
-                    "Automation composition element update failed");
+                DeployState.DEPLOYED, null, StateChangeResult.FAILED,
+                "Automation composition element update failed");
+
+            clearInvocations(listener);
+            var compositionTargetId = UUID.randomUUID();
+            var compositionElementTarget = new CompositionElementDto(compositionTargetId, new ToscaConceptIdentifier(),
+                properties, properties);
+            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
+                .migrate(compositionElement, compositionElementTarget, instanceElement, instanceElementUpdated);
+            threadHandler.migrate(messageId, compositionElement, compositionElementTarget,
+                instanceElement, instanceElementUpdated);
+            verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
+                DeployState.DEPLOYED, null, StateChangeResult.FAILED,
+                "Automation composition element migrate failed");
 
             clearInvocations(listener);
             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
+                .undeploy(compositionElement, instanceElement);
+            threadHandler.undeploy(messageId, compositionElement, instanceElement);
+            verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
+                DeployState.DEPLOYED, null, StateChangeResult.FAILED,
+                "Automation composition element undeploy failed");
+
+            clearInvocations(listener);
+            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
+                .delete(compositionElement, instanceElement);
+            threadHandler.delete(messageId, compositionElement, instanceElement);
+            verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
+                    DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
+                    "Automation composition element delete failed");
+        }
+    }
+
+    @Test
+    void testLock() throws PfModelException, IOException {
+        var listener = mock(AutomationCompositionElementListener.class);
+        var intermediaryApi = mock(ParticipantIntermediaryApi.class);
+        try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
+
+            Map<String, Object> properties = Map.of("key", "value");
+            var compositionElement = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
+                properties, properties);
+            var instanceElement = new InstanceElementDto(UUID.randomUUID(), UUID.randomUUID(),
+                null, properties, properties);
+            var messageId = UUID.randomUUID();
+            threadHandler.lock(messageId, compositionElement, instanceElement);
+            verify(listener, timeout(TIMEOUT)).lock(compositionElement, instanceElement);
+
+            clearInvocations(listener);
+            threadHandler.unlock(messageId, compositionElement, instanceElement);
+            verify(listener, timeout(TIMEOUT)).unlock(compositionElement, instanceElement);
+
+            clearInvocations(listener);
+            threadHandler.undeploy(messageId, compositionElement, instanceElement);
+            verify(listener, timeout(TIMEOUT)).undeploy(compositionElement, instanceElement);
+        }
+    }
+
+    @Test
+    void testLockException() throws PfModelException, IOException {
+        var listener = mock(AutomationCompositionElementListener.class);
+        var intermediaryApi = mock(ParticipantIntermediaryApi.class);
+        try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
+
+            Map<String, Object> properties = Map.of("key", "value");
+            var compositionElement = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
+                properties, properties);
+            var instanceId = UUID.randomUUID();
+            var elementId = UUID.randomUUID();
+            var instanceElement = new InstanceElementDto(instanceId, elementId, null, properties, properties);
+            var element = new AcElementDeploy();
+            element.setId(elementId);
+            var messageId = UUID.randomUUID();
+            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
                 .lock(compositionElement, instanceElement);
             threadHandler.lock(messageId, compositionElement, instanceElement);
             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
-                    null, LockState.UNLOCKED, StateChangeResult.FAILED, "Automation composition element lock failed");
+                null, LockState.UNLOCKED, StateChangeResult.FAILED, "Automation composition element lock failed");
 
             clearInvocations(listener);
             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
                 .unlock(compositionElement, instanceElement);
             threadHandler.unlock(messageId, compositionElement, instanceElement);
             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
-                    null, LockState.LOCKED, StateChangeResult.FAILED, "Automation composition element unlock failed");
+                null, LockState.LOCKED, StateChangeResult.FAILED, "Automation composition element unlock failed");
+        }
+    }
+
+    @Test
+    void testSubState() throws PfModelException, IOException {
+        var listener = mock(AutomationCompositionElementListener.class);
+        var intermediaryApi = mock(ParticipantIntermediaryApi.class);
+        try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
+
+            Map<String, Object> properties = Map.of("key", "value");
+            var compositionElement = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
+                properties, properties);
+            var instanceElement = new InstanceElementDto(UUID.randomUUID(), UUID.randomUUID(),
+                null, properties, properties);
+            var messageId = UUID.randomUUID();
+            threadHandler.prepare(messageId, compositionElement, instanceElement);
+            verify(listener, timeout(TIMEOUT)).prepare(compositionElement, instanceElement);
 
             clearInvocations(listener);
+            threadHandler.review(messageId, compositionElement, instanceElement);
+            verify(listener, timeout(TIMEOUT)).review(compositionElement, instanceElement);
+
+            clearInvocations(listener);
+            var instanceElementMigrate = new InstanceElementDto(instanceElement.instanceId(),
+                instanceElement.elementId(), null, properties, properties);
+            var compositionTargetId = UUID.randomUUID();
+            var compositionElementTarget = new CompositionElementDto(compositionTargetId, new ToscaConceptIdentifier(),
+                properties, properties);
+            threadHandler.migratePrecheck(messageId, compositionElement, compositionElementTarget,
+                instanceElement, instanceElementMigrate);
+            verify(listener, timeout(TIMEOUT)).migratePrecheck(compositionElement, compositionElementTarget,
+                instanceElement, instanceElementMigrate);
+        }
+    }
+
+    @Test
+    void testSubStateException() throws PfModelException, IOException {
+        var listener = mock(AutomationCompositionElementListener.class);
+        var intermediaryApi = mock(ParticipantIntermediaryApi.class);
+        try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
+
+            Map<String, Object> properties = Map.of("key", "value");
+            var compositionElement = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
+                properties, properties);
+            var instanceId = UUID.randomUUID();
+            var elementId = UUID.randomUUID();
+            var instanceElement = new InstanceElementDto(instanceId, elementId, null, properties, properties);
+            var element = new AcElementDeploy();
+            element.setId(elementId);
             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
-                .undeploy(compositionElement, instanceElement);
-            threadHandler.undeploy(messageId, compositionElement, instanceElement);
+                .prepare(compositionElement, instanceElement);
+            var messageId = UUID.randomUUID();
+            threadHandler.prepare(messageId, compositionElement, instanceElement);
             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
-                    DeployState.DEPLOYED, null, StateChangeResult.FAILED,
-                    "Automation composition element undeploy failed");
+                DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
+                "Automation composition element prepare Pre Deploy failed");
 
             clearInvocations(listener);
             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
-                .delete(compositionElement, instanceElement);
-            threadHandler.delete(messageId, compositionElement, instanceElement);
+                .review(compositionElement, instanceElement);
+            threadHandler.review(messageId, compositionElement, instanceElement);
             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
-                    DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
-                    "Automation composition element delete failed");
+                DeployState.DEPLOYED, null, StateChangeResult.FAILED,
+                "Automation composition element Review failed");
 
             clearInvocations(listener);
-            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).deprime(composition);
-            threadHandler.deprime(messageId, composition);
-            verify(intermediaryApi, timeout(TIMEOUT)).updateCompositionState(compositionId, AcTypeState.PRIMED,
-                    StateChangeResult.FAILED, "Composition Defintion deprime failed");
+            var compositionTargetId = UUID.randomUUID();
+            var compositionElementTarget = new CompositionElementDto(compositionTargetId, new ToscaConceptIdentifier(),
+                properties, properties);
+            var instanceElementMigrate = new InstanceElementDto(instanceElement.instanceId(),
+                instanceElement.elementId(), null, properties, properties);
+            doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener)
+                .migratePrecheck(compositionElement, compositionElementTarget, instanceElement, instanceElementMigrate);
+            threadHandler.migratePrecheck(messageId, compositionElement, compositionElementTarget,
+                instanceElement, instanceElementMigrate);
+            verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
+                DeployState.DEPLOYED, null, StateChangeResult.FAILED,
+                "Automation composition element migrate precheck failed");
         }
     }
 }