gerrit.onap Code Review - policy/clamp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024-2025 OpenInfra Foundation Europe. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.clamp.acm.participant.sim.main.handler;
  22
  23 import static org.mockito.Mockito.mock;
  24 import static org.mockito.Mockito.verify;
  25
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.UUID;
  30 import org.junit.jupiter.api.Test;
  31 import org.onap.policy.clamp.acm.participant.intermediary.api.CompositionDto;
  32 import org.onap.policy.clamp.acm.participant.intermediary.api.CompositionElementDto;
  33 import org.onap.policy.clamp.acm.participant.intermediary.api.ElementState;
  34 import org.onap.policy.clamp.acm.participant.intermediary.api.InstanceElementDto;
  35 import org.onap.policy.clamp.acm.participant.intermediary.api.ParticipantIntermediaryApi;
  36 import org.onap.policy.clamp.acm.participant.sim.comm.CommonTestData;
  37 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  38 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  39 import org.onap.policy.clamp.models.acm.concepts.LockState;
  40 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  41 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  42
  43 class AutomationCompositionElementHandlerTest {
  44
  45     private static final ToscaConceptIdentifier ELEMENT_DEFINITION_ID = new ToscaConceptIdentifier("name", "1.0.0");
  46     private static final CompositionElementDto COMPOSITION_ELEMENT =
  47         new CompositionElementDto(UUID.randomUUID(), ELEMENT_DEFINITION_ID, Map.of(), Map.of());
  48     private static final InstanceElementDto INSTANCE_ELEMENT =
  49         new InstanceElementDto(UUID.randomUUID(), UUID.randomUUID(), Map.of(), new HashMap<>());
  50     private static final CompositionDto COMPOSITION = new CompositionDto(UUID.randomUUID(),
  51         Map.of(ELEMENT_DEFINITION_ID, Map.of()), Map.of(ELEMENT_DEFINITION_ID, new HashMap<>()));
  52
  53     @Test
  54     void testDeploy() {
  55         var config = CommonTestData.createSimConfig();
  56         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
  57         var simulatorService = new SimulatorService(intermediaryApi);
  58         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
  59         simulatorService.setConfig(config);
  60         acElementHandler.deploy(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
  61         verify(intermediaryApi).updateAutomationCompositionElementState(
  62             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DEPLOYED,
  63             null, StateChangeResult.NO_ERROR, "Deployed");
  64
  65         config.setDeploySuccess(false);
  66         acElementHandler.deploy(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
  67         verify(intermediaryApi).updateAutomationCompositionElementState(
  68             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.UNDEPLOYED,
  69             null, StateChangeResult.FAILED, "Deploy failed!");
  70     }
  71
  72     @Test
  73     void testUndeploy() {
  74         var config = CommonTestData.createSimConfig();
  75         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
  76         var simulatorService = new SimulatorService(intermediaryApi);
  77         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
  78         simulatorService.setConfig(config);
  79         acElementHandler.undeploy(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
  80         verify(intermediaryApi).updateAutomationCompositionElementState(
  81             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.UNDEPLOYED,
  82             null, StateChangeResult.NO_ERROR, "Undeployed");
  83
  84         config.setUndeploySuccess(false);
  85         acElementHandler.undeploy(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
  86         verify(intermediaryApi).updateAutomationCompositionElementState(
  87             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DEPLOYED,
  88             null, StateChangeResult.FAILED, "Undeploy failed!");
  89     }
  90
  91     @Test
  92     void testLock() {
  93         var config = CommonTestData.createSimConfig();
  94         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
  95         var simulatorService = new SimulatorService(intermediaryApi);
  96         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
  97         simulatorService.setConfig(config);
  98         acElementHandler.lock(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
  99         verify(intermediaryApi).updateAutomationCompositionElementState(
 100             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), null, LockState.LOCKED,
 101             StateChangeResult.NO_ERROR, "Locked");
 102
 103         config.setLockSuccess(false);
 104         acElementHandler.lock(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 105         verify(intermediaryApi).updateAutomationCompositionElementState(
 106             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), null, LockState.UNLOCKED,
 107             StateChangeResult.FAILED, "Lock failed!");
 108     }
 109
 110     @Test
 111     void testUnlock() {
 112         var config = CommonTestData.createSimConfig();
 113         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 114         var simulatorService = new SimulatorService(intermediaryApi);
 115         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 116         simulatorService.setConfig(config);
 117         acElementHandler.unlock(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 118         verify(intermediaryApi).updateAutomationCompositionElementState(
 119             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), null, LockState.UNLOCKED,
 120             StateChangeResult.NO_ERROR, "Unlocked");
 121
 122         config.setUnlockSuccess(false);
 123         acElementHandler.unlock(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 124         verify(intermediaryApi).updateAutomationCompositionElementState(
 125             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), null, LockState.LOCKED,
 126             StateChangeResult.FAILED, "Unlock failed!");
 127     }
 128
 129     @Test
 130     void testUpdate() {
 131         var config = CommonTestData.createSimConfig();
 132         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 133         var simulatorService = new SimulatorService(intermediaryApi);
 134         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 135         simulatorService.setConfig(config);
 136         var instanceElementUpdated = new InstanceElementDto(
 137             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 138             Map.of("key", "value"), Map.of());
 139         acElementHandler.update(COMPOSITION_ELEMENT, INSTANCE_ELEMENT, instanceElementUpdated);
 140         verify(intermediaryApi).updateAutomationCompositionElementState(
 141             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 142             DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Updated");
 143
 144         config.setUpdateSuccess(false);
 145         acElementHandler.update(COMPOSITION_ELEMENT, INSTANCE_ELEMENT, instanceElementUpdated);
 146         verify(intermediaryApi).updateAutomationCompositionElementState(
 147             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 148             DeployState.DEPLOYED, null, StateChangeResult.FAILED, "Update failed!");
 149     }
 150
 151     @Test
 152     void testDelete() {
 153         var config = CommonTestData.createSimConfig();
 154         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 155         var simulatorService = new SimulatorService(intermediaryApi);
 156         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 157         simulatorService.setConfig(config);
 158         acElementHandler.delete(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 159         verify(intermediaryApi).updateAutomationCompositionElementState(
 160             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DELETED,
 161             null, StateChangeResult.NO_ERROR, "Deleted");
 162
 163         config.setDeleteSuccess(false);
 164         acElementHandler.delete(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 165         verify(intermediaryApi).updateAutomationCompositionElementState(
 166             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.UNDEPLOYED,
 167             null, StateChangeResult.FAILED, "Delete failed!");
 168     }
 169
 170     @Test
 171     void testPrime() {
 172         var config = CommonTestData.createSimConfig();
 173         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 174         var simulatorService = new SimulatorService(intermediaryApi);
 175         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 176         simulatorService.setConfig(config);
 177         acElementHandler.prime(COMPOSITION);
 178         verify(intermediaryApi).updateCompositionState(
 179             COMPOSITION.compositionId(), AcTypeState.PRIMED, StateChangeResult.NO_ERROR, "Primed");
 180
 181         config.setPrimeSuccess(false);
 182         acElementHandler.prime(COMPOSITION);
 183         verify(intermediaryApi).updateCompositionState(
 184             COMPOSITION.compositionId(), AcTypeState.COMMISSIONED, StateChangeResult.FAILED, "Prime failed!");
 185     }
 186
 187     @Test
 188     void testDeprime() {
 189         var config = CommonTestData.createSimConfig();
 190         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 191         var simulatorService = new SimulatorService(intermediaryApi);
 192         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 193         simulatorService.setConfig(config);
 194         acElementHandler.deprime(COMPOSITION);
 195         verify(intermediaryApi).updateCompositionState(
 196             COMPOSITION.compositionId(), AcTypeState.COMMISSIONED, StateChangeResult.NO_ERROR, "Deprimed");
 197
 198         config.setDeprimeSuccess(false);
 199         acElementHandler.deprime(COMPOSITION);
 200         verify(intermediaryApi).updateCompositionState(
 201             COMPOSITION.compositionId(), AcTypeState.PRIMED, StateChangeResult.FAILED, "Deprime failed!");
 202     }
 203
 204     @Test
 205     void testMigrate() {
 206         var config = CommonTestData.createSimConfig();
 207         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 208         var simulatorService = new SimulatorService(intermediaryApi);
 209         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 210         simulatorService.setConfig(config);
 211         var compositionElementTarget = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 212             Map.of(), Map.of());
 213         var instanceElementMigrated = new InstanceElementDto(
 214             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 215             Map.of("key", "value"), new HashMap<>());
 216         acElementHandler
 217             .migrate(COMPOSITION_ELEMENT, compositionElementTarget, INSTANCE_ELEMENT, instanceElementMigrated, 0);
 218         verify(intermediaryApi).updateAutomationCompositionElementState(
 219             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 220             DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Migrated");
 221
 222         config.setMigrateSuccess(false);
 223         acElementHandler
 224             .migrate(COMPOSITION_ELEMENT, compositionElementTarget, INSTANCE_ELEMENT, instanceElementMigrated, 0);
 225         verify(intermediaryApi).updateAutomationCompositionElementState(
 226             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 227             DeployState.DEPLOYED, null, StateChangeResult.FAILED, "Migrate failed!");
 228     }
 229
 230     @Test
 231     void testMigrateStage() {
 232         var config = CommonTestData.createSimConfig();
 233         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 234         var simulatorService = new SimulatorService(intermediaryApi);
 235         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 236         simulatorService.setConfig(config);
 237         var compositionElementTarget = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 238             Map.of("stage", List.of(1, 2)), Map.of());
 239         var instanceElementMigrated = new InstanceElementDto(INSTANCE_ELEMENT.instanceId(),
 240             INSTANCE_ELEMENT.elementId(), Map.of(), new HashMap<>());
 241         acElementHandler
 242             .migrate(COMPOSITION_ELEMENT, compositionElementTarget, INSTANCE_ELEMENT, instanceElementMigrated, 1);
 243         verify(intermediaryApi).updateAutomationCompositionElementStage(
 244             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 245             StateChangeResult.NO_ERROR, 2, "stage 1 Migrated");
 246     }
 247
 248     @Test
 249     void testMigrateAdd() {
 250         var config = CommonTestData.createSimConfig();
 251         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 252         var simulatorService = new SimulatorService(intermediaryApi);
 253         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 254         simulatorService.setConfig(config);
 255         var compositionElement = new CompositionElementDto(
 256             UUID.randomUUID(), new ToscaConceptIdentifier(), Map.of(), Map.of(), ElementState.NOT_PRESENT);
 257
 258         var instanceElement = new InstanceElementDto(
 259             UUID.randomUUID(), UUID.randomUUID(), Map.of(), Map.of(), ElementState.NOT_PRESENT);
 260
 261         var compoElTargetAdd = new CompositionElementDto(
 262             UUID.randomUUID(), new ToscaConceptIdentifier(), Map.of(), Map.of(), ElementState.NEW);
 263         var inElMigratedAdd = new InstanceElementDto(instanceElement.instanceId(), instanceElement.elementId(),
 264             Map.of(), new HashMap<>(), ElementState.NEW);
 265         acElementHandler
 266             .migrate(compositionElement, compoElTargetAdd, instanceElement, inElMigratedAdd, 0);
 267         verify(intermediaryApi).updateAutomationCompositionElementState(
 268             instanceElement.instanceId(), instanceElement.elementId(),
 269             DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Migrated");
 270     }
 271
 272     @Test
 273     void testMigrateRemove() {
 274         var config = CommonTestData.createSimConfig();
 275         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 276         var simulatorService = new SimulatorService(intermediaryApi);
 277         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 278         simulatorService.setConfig(config);
 279
 280         var compoElTargetRemove = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 281             Map.of(), Map.of(), ElementState.REMOVED);
 282         var inElMigratedRemove = new InstanceElementDto(
 283             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 284             Map.of("key", "value"), Map.of(), ElementState.REMOVED);
 285         acElementHandler
 286             .migrate(COMPOSITION_ELEMENT, compoElTargetRemove, INSTANCE_ELEMENT, inElMigratedRemove, 0);
 287         verify(intermediaryApi).updateAutomationCompositionElementState(
 288             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 289             DeployState.UNDEPLOYED, null, StateChangeResult.NO_ERROR, "Undeployed");
 290         verify(intermediaryApi).updateAutomationCompositionElementState(
 291             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 292             DeployState.DELETED, null, StateChangeResult.NO_ERROR, "Deleted");
 293     }
 294
 295     @Test
 296     void testMigratePrecheck() {
 297         var config = CommonTestData.createSimConfig();
 298         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 299         var simulatorService = new SimulatorService(intermediaryApi);
 300         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 301         simulatorService.setConfig(config);
 302         var compositionElementTarget = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 303             Map.of(), Map.of());
 304         var instanceElementMigrated = new InstanceElementDto(
 305             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 306             Map.of("key", "value"), Map.of());
 307         acElementHandler.migratePrecheck(COMPOSITION_ELEMENT, compositionElementTarget,
 308             INSTANCE_ELEMENT, instanceElementMigrated);
 309         verify(intermediaryApi).updateAutomationCompositionElementState(
 310             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 311             DeployState.DEPLOYED, null,
 312             StateChangeResult.NO_ERROR, "Migration precheck completed");
 313
 314         config.setMigratePrecheck(false);
 315         acElementHandler.migratePrecheck(COMPOSITION_ELEMENT, compositionElementTarget,
 316             INSTANCE_ELEMENT, instanceElementMigrated);
 317         verify(intermediaryApi).updateAutomationCompositionElementState(
 318             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 319             DeployState.DEPLOYED, null,
 320             StateChangeResult.FAILED, "Migration precheck failed");
 321     }
 322
 323     @Test
 324     void testPrepare() {
 325         var config = CommonTestData.createSimConfig();
 326         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 327         var simulatorService = new SimulatorService(intermediaryApi);
 328         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 329         simulatorService.setConfig(config);
 330         acElementHandler.prepare(COMPOSITION_ELEMENT, INSTANCE_ELEMENT, 0);
 331         verify(intermediaryApi).updateAutomationCompositionElementState(
 332             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.UNDEPLOYED,
 333             null, StateChangeResult.NO_ERROR, "Prepare completed");
 334
 335         config.setPrepare(false);
 336         acElementHandler.prepare(COMPOSITION_ELEMENT, INSTANCE_ELEMENT, 0);
 337         verify(intermediaryApi).updateAutomationCompositionElementState(
 338             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.UNDEPLOYED,
 339             null, StateChangeResult.FAILED, "Prepare failed");
 340     }
 341
 342     @Test
 343     void testReview() {
 344         var config = CommonTestData.createSimConfig();
 345         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 346         var simulatorService = new SimulatorService(intermediaryApi);
 347         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 348         simulatorService.setConfig(config);
 349         acElementHandler.review(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 350         verify(intermediaryApi).updateAutomationCompositionElementState(
 351             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DEPLOYED,
 352             null, StateChangeResult.NO_ERROR, "Review completed");
 353
 354         config.setReview(false);
 355         acElementHandler.review(COMPOSITION_ELEMENT, INSTANCE_ELEMENT);
 356         verify(intermediaryApi).updateAutomationCompositionElementState(
 357             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DEPLOYED,
 358             null, StateChangeResult.FAILED, "Review failed");
 359     }
 360
 361     @Test
 362     void testRollback() {
 363         var config = CommonTestData.createSimConfig();
 364         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 365         var simulatorService = new SimulatorService(intermediaryApi);
 366         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 367         simulatorService.setConfig(config);
 368         var compositionElementRollback = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 369                 Map.of(), Map.of());
 370         var instanceElementRollback = new InstanceElementDto(
 371                 INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 372                 Map.of("key", "value"), new HashMap<>());
 373         acElementHandler.rollbackMigration(COMPOSITION_ELEMENT, compositionElementRollback, INSTANCE_ELEMENT,
 374                 instanceElementRollback, 0);
 375         verify(intermediaryApi).updateAutomationCompositionElementState(
 376                 INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DEPLOYED,
 377                 null, StateChangeResult.NO_ERROR, "Migration rollback done");
 378
 379         config.setRollback(false);
 380         acElementHandler.rollbackMigration(COMPOSITION_ELEMENT, compositionElementRollback, INSTANCE_ELEMENT,
 381                 instanceElementRollback, 0);
 382         verify(intermediaryApi).updateAutomationCompositionElementState(
 383             INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(), DeployState.DEPLOYED,
 384             null, StateChangeResult.FAILED, "Migration rollback failed");
 385     }
 386
 387
 388     @Test
 389     void testRollbackStage() {
 390         var config = CommonTestData.createSimConfig();
 391         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 392         var simulatorService = new SimulatorService(intermediaryApi);
 393         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 394         simulatorService.setConfig(config);
 395         var compositionElementRollback = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 396                 Map.of("stage", List.of(1, 2)), Map.of());
 397         var instanceElementRollback = new InstanceElementDto(INSTANCE_ELEMENT.instanceId(),
 398                 INSTANCE_ELEMENT.elementId(), Map.of(), new HashMap<>());
 399         acElementHandler.rollbackMigration(COMPOSITION_ELEMENT, compositionElementRollback, INSTANCE_ELEMENT,
 400                 instanceElementRollback, 1);
 401         verify(intermediaryApi).updateAutomationCompositionElementStage(
 402                 INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 403                 StateChangeResult.NO_ERROR, 2, "stage 1 Migration rollback");
 404     }
 405
 406     @Test
 407     void testRollbackAdd() {
 408         var config = CommonTestData.createSimConfig();
 409         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 410         var simulatorService = new SimulatorService(intermediaryApi);
 411         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 412         simulatorService.setConfig(config);
 413         var compositionElement = new CompositionElementDto(
 414                 UUID.randomUUID(), new ToscaConceptIdentifier(), Map.of(), Map.of(), ElementState.NOT_PRESENT);
 415
 416         var instanceElement = new InstanceElementDto(
 417                 UUID.randomUUID(), UUID.randomUUID(), Map.of(), Map.of(), ElementState.NOT_PRESENT);
 418
 419         var compoElRollbackAdd = new CompositionElementDto(
 420                 UUID.randomUUID(), new ToscaConceptIdentifier(), Map.of(), Map.of(), ElementState.NEW);
 421         var inElRollbackAdd = new InstanceElementDto(instanceElement.instanceId(), instanceElement.elementId(),
 422                 Map.of(), new HashMap<>(), ElementState.NEW);
 423         acElementHandler
 424                 .rollbackMigration(compositionElement, compoElRollbackAdd, instanceElement, inElRollbackAdd, 0);
 425         verify(intermediaryApi).updateAutomationCompositionElementState(
 426                 instanceElement.instanceId(), instanceElement.elementId(),
 427                 DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Migration rollback done");
 428     }
 429
 430     @Test
 431     void testRollbackRemove() {
 432         var config = CommonTestData.createSimConfig();
 433         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 434         var simulatorService = new SimulatorService(intermediaryApi);
 435         var acElementHandler = new AutomationCompositionElementHandler(intermediaryApi, simulatorService);
 436         simulatorService.setConfig(config);
 437
 438         var compoElRollbackRemove = new CompositionElementDto(UUID.randomUUID(), new ToscaConceptIdentifier(),
 439                 Map.of(), Map.of(), ElementState.REMOVED);
 440         var inElRollbackRemove = new InstanceElementDto(
 441                 INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 442                 Map.of("key", "value"), Map.of(), ElementState.REMOVED);
 443         acElementHandler
 444                 .rollbackMigration(COMPOSITION_ELEMENT, compoElRollbackRemove, INSTANCE_ELEMENT, inElRollbackRemove, 0);
 445         verify(intermediaryApi).updateAutomationCompositionElementState(
 446                 INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 447                 DeployState.UNDEPLOYED, null, StateChangeResult.NO_ERROR, "Undeployed");
 448         verify(intermediaryApi).updateAutomationCompositionElementState(
 449                 INSTANCE_ELEMENT.instanceId(), INSTANCE_ELEMENT.elementId(),
 450                 DeployState.DELETED, null, StateChangeResult.NO_ERROR, "Deleted");
 451     }
 452 }