a604fd57718eee2860c27329dd4639596349c03b
[policy/clamp.git] /
1 /*-
2  * ============LICENSE_START=======================================================
3  *  Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
4  *  Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
5  * ================================================================================
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *      http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *
18  * SPDX-License-Identifier: Apache-2.0
19  * ============LICENSE_END=========================================================
20  */
21
22 package org.onap.policy.clamp.acm.runtime.instantiation;
23
24 import static org.assertj.core.api.Assertions.assertThat;
25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
26 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
27 import static org.junit.jupiter.api.Assertions.assertEquals;
28 import static org.junit.jupiter.api.Assertions.assertThrows;
29 import static org.mockito.ArgumentMatchers.any;
30 import static org.mockito.Mockito.doNothing;
31 import static org.mockito.Mockito.mock;
32 import static org.mockito.Mockito.never;
33 import static org.mockito.Mockito.verify;
34 import static org.mockito.Mockito.when;
35 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
36
37 import java.util.ArrayList;
38 import java.util.List;
39 import java.util.Optional;
40 import java.util.UUID;
41 import org.junit.jupiter.api.BeforeAll;
42 import org.junit.jupiter.api.Test;
43 import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
44 import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
45 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
46 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
47 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
48 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
49 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
50 import org.onap.policy.clamp.models.acm.concepts.DeployState;
51 import org.onap.policy.clamp.models.acm.concepts.LockState;
52 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
53 import org.onap.policy.clamp.models.acm.concepts.SubState;
54 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
55 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
56 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
57 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.SubOrder;
58 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationCompositionRollback;
59 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
60 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
61 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
62 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
63 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
64 import org.onap.policy.clamp.models.acm.utils.AcmUtils;
65 import org.onap.policy.models.base.PfConceptKey;
66 import org.onap.policy.models.base.PfModelRuntimeException;
67 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
68 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
69 import org.springframework.data.domain.Pageable;
70
71 /**
72  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
73  *
74  */
75 class AutomationCompositionInstantiationProviderTest {
76
77     public static final String MIGRATION_SERVICE_TEMPLATE_YAML = "clamp/acm/pmsh/funtional-pmsh-usecase-migration.yaml";
78     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
79     private static final String AC_INSTANTIATION_UPDATE_JSON =
80             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
81     private static final String AC_MIGRATE_JSON = "src/test/resources/rest/acm/AutomationCompositionMigrate.json";
82
83     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
84             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
85     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
86             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
87     private static final String DELETE_BAD_REQUEST = "Not valid order DELETE;";
88
89     private static final String AC_ELEMENT_NAME_NOT_FOUND = """
90                 "entry org.onap.domain.pmsh.DCAEMicroservice" INVALID, Not found
91                 "entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement" INVALID, Not found
92             """;
93     private static final String AC_DEFINITION_NOT_FOUND = """
94             "AutomationComposition" INVALID, item has status INVALID
95               item "ServiceTemplate" value "%s" INVALID, Commissioned automation composition definition not found
96             """;
97
98     private static final String DO_NOT_MATCH = " do not match with ";
99
100     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
101     private static ToscaServiceTemplate serviceTemplateMigration = new ToscaServiceTemplate();
102
103     @BeforeAll
104     public static void setUpBeforeClass() {
105         var st = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
106         var jpa = ProviderUtils.getJpaAndValidate(st, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
107         serviceTemplate = jpa.toAuthorative();
108
109         st = InstantiationUtils.getToscaServiceTemplate(MIGRATION_SERVICE_TEMPLATE_YAML);
110         jpa = ProviderUtils.getJpaAndValidate(st, JpaToscaServiceTemplate::new, "migrationServiceTemplate");
111         serviceTemplateMigration = jpa.toAuthorative();
112     }
113
114     @Test
115     void testGetAutomationCompositionsWithNull() {
116         var instantiationProvider = new AutomationCompositionInstantiationProvider(
117                 mock(AutomationCompositionProvider.class), mock(AcDefinitionProvider.class),
118                 new AcInstanceStateResolver(), mock(SupervisionAcHandler.class), mock(ParticipantProvider.class),
119                 CommonTestData.getTestParamaterGroup(), new EncryptionUtils(CommonTestData.getTestParamaterGroup()));
120         assertThatThrownBy(() -> instantiationProvider
121                 .getAutomationCompositions(null, null, null, Pageable.unpaged()))
122                 .hasMessage("compositionId is marked non-null but is null");
123         assertThatThrownBy(() -> instantiationProvider
124                 .getAutomationCompositions(UUID.randomUUID(), null, null, null))
125                 .hasMessage("pageable is marked non-null but is null");
126     }
127
128     @Test
129     void testInstantiationCrud() {
130         var acDefinitionProvider = mock(AcDefinitionProvider.class);
131         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
132         var compositionId = acDefinition.getCompositionId();
133         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
134         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
135         var acProvider = mock(AutomationCompositionProvider.class);
136         var supervisionAcHandler = mock(SupervisionAcHandler.class);
137         var participantProvider = mock(ParticipantProvider.class);
138         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
139         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
140                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
141                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
142         var automationCompositionCreate =
143                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
144         automationCompositionCreate.setCompositionId(compositionId);
145         when(acProvider.createAutomationComposition(automationCompositionCreate))
146                 .thenReturn(automationCompositionCreate);
147
148         var instantiationResponse = instantiationProvider.createAutomationComposition(
149                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
150         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
151
152         verify(acProvider).createAutomationComposition(automationCompositionCreate);
153
154         when(acProvider.getAutomationCompositions(compositionId, automationCompositionCreate.getName(),
155                 automationCompositionCreate.getVersion(), Pageable.unpaged()))
156                 .thenReturn(List.of(automationCompositionCreate));
157
158         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
159                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion(), Pageable.unpaged());
160         assertThat(automationCompositionCreate)
161                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
162
163         var automationCompositionUpdate =
164                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
165         automationCompositionUpdate.setCompositionId(compositionId);
166         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
167                 .thenReturn(automationCompositionUpdate);
168         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
169                 .thenReturn(automationCompositionUpdate);
170
171         instantiationResponse = instantiationProvider.updateAutomationComposition(
172                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
173         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
174
175         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
176
177         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
178                 .thenReturn(automationCompositionUpdate);
179         doNothing().when(participantProvider).verifyParticipantState(any());
180         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
181                 automationCompositionCreate.getInstanceId());
182
183         verify(supervisionAcHandler).delete(any(), any());
184     }
185
186     @Test
187     void testInstantiationUpdate() {
188         var acDefinitionProvider = mock(AcDefinitionProvider.class);
189         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
190         var compositionId = acDefinition.getCompositionId();
191         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
192
193         var automationCompositionUpdate =
194                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
195         automationCompositionUpdate.setCompositionId(compositionId);
196         automationCompositionUpdate.setInstanceId(UUID.randomUUID());
197         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
198         automationCompositionUpdate.setLockState(LockState.LOCKED);
199         var acProvider = mock(AutomationCompositionProvider.class);
200         var acmFromDb = new AutomationComposition(automationCompositionUpdate);
201         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId())).thenReturn(acmFromDb);
202         when(acProvider.updateAutomationComposition(acmFromDb)).thenReturn(acmFromDb);
203
204         var supervisionAcHandler = mock(SupervisionAcHandler.class);
205         var participantProvider = mock(ParticipantProvider.class);
206         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
207         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
208                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
209                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
210
211         var instantiationResponse = instantiationProvider.updateAutomationComposition(
212                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
213
214         verify(supervisionAcHandler).update(any());
215         verify(acProvider).updateAutomationComposition(acmFromDb);
216         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
217
218         var elements = new ArrayList<>(automationCompositionUpdate.getElements().values());
219         automationCompositionUpdate.getElements().clear();
220         for (var element : elements) {
221             element.setId(UUID.randomUUID());
222             automationCompositionUpdate.getElements().put(element.getId(), element);
223         }
224         acmFromDb.getElements().values().forEach(element -> element.setDeployState(DeployState.DEPLOYED));
225         acmFromDb.setDeployState(DeployState.DEPLOYED);
226         assertThatThrownBy(
227                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
228                 .hasMessageStartingWith("Element id not present ");
229
230     }
231
232     @Test
233     void testUpdateBadRequest() {
234         var automationCompositionUpdate =
235                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
236         automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
237         automationCompositionUpdate.setLockState(LockState.NONE);
238         var acProvider = mock(AutomationCompositionProvider.class);
239         var encryptionUtils = mock(EncryptionUtils.class);
240         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
241                 .thenReturn(automationCompositionUpdate);
242
243         var instantiationProvider =
244             new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
245                 new AcInstanceStateResolver(), mock(SupervisionAcHandler.class), mock(ParticipantProvider.class),
246                 mock(AcRuntimeParameterGroup.class), encryptionUtils);
247
248         var compositionId = automationCompositionUpdate.getCompositionId();
249         assertThatThrownBy(
250                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
251                         .hasMessageMatching(
252                                 "Not allowed to UPDATE in the state " + automationCompositionUpdate.getDeployState());
253
254         automationCompositionUpdate.setDeployState(DeployState.UPDATING);
255         automationCompositionUpdate.setLockState(LockState.LOCKED);
256         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
257         assertThatThrownBy(
258                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
259                         .hasMessageMatching(
260                                 "Not allowed to MIGRATE in the state " + automationCompositionUpdate.getDeployState());
261     }
262
263     @Test
264     void testMigrationAddRemoveElements() {
265         var acDefinitionProvider = mock(AcDefinitionProvider.class);
266         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
267         var compositionId = acDefinition.getCompositionId();
268         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
269         var instanceId = UUID.randomUUID();
270
271         var automationComposition =
272                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
273         automationComposition.setCompositionId(compositionId);
274         automationComposition.setInstanceId(instanceId);
275         automationComposition.setDeployState(DeployState.DEPLOYED);
276         automationComposition.setLockState(LockState.LOCKED);
277         var acProvider = mock(AutomationCompositionProvider.class);
278         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
279                 .thenReturn(automationComposition);
280
281         var automationCompositionTarget =
282                 InstantiationUtils.getAutomationCompositionFromResource(AC_MIGRATE_JSON, "Migrate");
283         automationCompositionTarget.setInstanceId(instanceId);
284         automationCompositionTarget.setCompositionId(compositionId);
285         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplateMigration, AcTypeState.PRIMED);
286         var compositionTargetId = acDefinitionTarget.getCompositionId();
287         automationCompositionTarget.setCompositionTargetId(compositionTargetId);
288         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
289         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
290         when(acProvider.updateAutomationComposition(any())).thenReturn(automationCompositionTarget);
291
292         var supervisionAcHandler = mock(SupervisionAcHandler.class);
293         var participantProvider = mock(ParticipantProvider.class);
294         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
295         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
296                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
297                 new AcRuntimeParameterGroup(), encryptionUtils);
298
299         automationCompositionTarget.setPrecheck(true);
300         var preCheckResponse = instantiationProvider.updateAutomationComposition(compositionId,
301                 automationCompositionTarget);
302         verify(supervisionAcHandler).migratePrecheck(any());
303         InstantiationUtils.assertInstantiationResponse(preCheckResponse, automationCompositionTarget);
304
305         automationCompositionTarget.setPrecheck(false);
306         AcmUtils.setCascadedState(automationComposition, DeployState.DEPLOYED, LockState.LOCKED,
307                 SubState.NONE);
308         var instantiationResponse = instantiationProvider.updateAutomationComposition(compositionId,
309                         automationCompositionTarget);
310
311         verify(supervisionAcHandler).migrate(any());
312         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionTarget);
313     }
314
315     @Test
316     void testVersionCompatibility() {
317         var acProvider = mock(AutomationCompositionProvider.class);
318         var acDefinitionProvider = mock(AcDefinitionProvider.class);
319         var supervisionAcHandler = mock(SupervisionAcHandler.class);
320         var participantProvider = mock(ParticipantProvider.class);
321         var newDefinition = new PfConceptKey("policy.clamp.element", "1.2.3");
322         var oldDefinition = new PfConceptKey("policy.clamp.element", "2.2.3");
323
324         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
325                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
326                 new AcRuntimeParameterGroup(), null);
327         var instanceId = UUID.randomUUID();
328         assertDoesNotThrow(() -> {
329             instantiationProvider.checkCompatibility(newDefinition, oldDefinition, instanceId);
330         }, "No exception for major version update");
331
332         // Not compatible
333         newDefinition.setName("policy.clamp.newElement");
334         newDefinition.setVersion("2.2.4");
335
336         assertThatThrownBy(() -> instantiationProvider
337                 .checkCompatibility(newDefinition, oldDefinition, instanceId))
338                 .hasMessageContaining("is not compatible");
339     }
340
341     @Test
342     void testInstantiationMigration() {
343         var acDefinitionProvider = mock(AcDefinitionProvider.class);
344         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
345         var compositionId = acDefinition.getCompositionId();
346         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
347
348         var automationComposition =
349                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
350         automationComposition.setCompositionId(compositionId);
351         automationComposition.setDeployState(DeployState.DEPLOYED);
352         automationComposition.setLockState(LockState.LOCKED);
353         automationComposition.setCompositionTargetId(UUID.randomUUID());
354         var acProvider = mock(AutomationCompositionProvider.class);
355         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
356                 .thenReturn(automationComposition);
357         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
358
359         var supervisionAcHandler = mock(SupervisionAcHandler.class);
360         var participantProvider = mock(ParticipantProvider.class);
361         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
362         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
363             new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
364                 encryptionUtils);
365
366         assertThatThrownBy(() -> instantiationProvider
367                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
368                         .hasMessageMatching(
369                                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
370
371         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
372         var compositionTargetId = acDefinitionTarget.getCompositionId();
373         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
374         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
375
376         automationComposition.setCompositionTargetId(compositionTargetId);
377
378         var instantiationResponse = instantiationProvider
379                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
380
381         verify(supervisionAcHandler).migrate(any());
382         verify(acProvider).updateAutomationComposition(automationComposition);
383         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
384     }
385
386     @Test
387     void testInstantiationMigrationPrecheck() {
388         var acDefinitionProvider = mock(AcDefinitionProvider.class);
389         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
390         var compositionId = acDefinition.getCompositionId();
391         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
392
393         var automationComposition =
394             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
395         automationComposition.setCompositionId(compositionId);
396         automationComposition.setDeployState(DeployState.DEPLOYED);
397         automationComposition.setLockState(LockState.LOCKED);
398         automationComposition.setCompositionTargetId(UUID.randomUUID());
399         automationComposition.setPrecheck(true);
400         var acProvider = mock(AutomationCompositionProvider.class);
401         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
402             .thenReturn(automationComposition);
403         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
404
405         var supervisionAcHandler = mock(SupervisionAcHandler.class);
406         var acmParticipantProvider = mock(ParticipantProvider.class);
407         var encryptionUtils = mock(EncryptionUtils.class);
408         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
409             new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup(),
410                 encryptionUtils);
411
412         assertThatThrownBy(() -> instantiationProvider
413             .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
414             .hasMessageMatching(
415                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
416
417         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
418         var compositionTargetId = acDefinitionTarget.getCompositionId();
419         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
420
421         automationComposition.setCompositionTargetId(compositionTargetId);
422
423         var instantiationResponse = instantiationProvider
424             .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
425
426         verify(supervisionAcHandler).migratePrecheck(any());
427         verify(acProvider).updateAutomationComposition(automationComposition);
428         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
429     }
430
431     @Test
432     void testMigrateBadRequest() {
433         var acDefinitionProvider = mock(AcDefinitionProvider.class);
434         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
435         var compositionId = acDefinition.getCompositionId();
436         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
437
438         var automationComposition =
439                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
440         automationComposition.setCompositionId(compositionId);
441         automationComposition.setDeployState(DeployState.DEPLOYED);
442         automationComposition.setLockState(LockState.LOCKED);
443         var acProvider = mock(AutomationCompositionProvider.class);
444         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
445                 .thenReturn(automationComposition);
446         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
447
448         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
449         var compositionTargetId = acDefinitionTarget.getCompositionId();
450         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
451
452         var acMigrate = new AutomationComposition(automationComposition);
453         acMigrate.setCompositionTargetId(compositionTargetId);
454         automationComposition.setDeployState(DeployState.DEPLOYING);
455
456         var supervisionAcHandler = mock(SupervisionAcHandler.class);
457         var participantProvider = mock(ParticipantProvider.class);
458         var encryptionUtils = mock(EncryptionUtils.class);
459         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
460                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
461                 new AcRuntimeParameterGroup(), encryptionUtils);
462
463         assertThatThrownBy(() -> instantiationProvider
464                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
465                 .hasMessageStartingWith("Not allowed to MIGRATE in the state DEPLOYING");
466     }
467
468     @Test
469     void testMigratePreCheckBadRequest() {
470         var acDefinitionProvider = mock(AcDefinitionProvider.class);
471         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
472         var compositionId = acDefinition.getCompositionId();
473         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
474
475         var automationComposition =
476                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
477         automationComposition.setCompositionId(compositionId);
478         automationComposition.setDeployState(DeployState.DEPLOYED);
479         automationComposition.setLockState(LockState.LOCKED);
480         automationComposition.setPrecheck(true);
481         var acProvider = mock(AutomationCompositionProvider.class);
482         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
483                 .thenReturn(automationComposition);
484         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
485
486         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
487         var compositionTargetId = acDefinitionTarget.getCompositionId();
488         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
489
490         var acMigrate = new AutomationComposition(automationComposition);
491         acMigrate.setCompositionTargetId(compositionTargetId);
492         automationComposition.setDeployState(DeployState.DEPLOYING);
493         automationComposition.setPrecheck(true);
494
495         var supervisionAcHandler = mock(SupervisionAcHandler.class);
496         var participantProvider = mock(ParticipantProvider.class);
497         var encryptionUtils = mock(EncryptionUtils.class);
498         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
499                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
500                 new AcRuntimeParameterGroup(), encryptionUtils);
501
502         assertThatThrownBy(() -> instantiationProvider
503                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
504                 .hasMessageStartingWith("Not allowed to NONE in the state DEPLOYING");
505     }
506
507     @Test
508     void testInstantiationDelete() {
509         var automationComposition =
510                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
511         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
512         var acProvider = mock(AutomationCompositionProvider.class);
513         var acDefinitionProvider = mock(AcDefinitionProvider.class);
514         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
515         var compositionId = acDefinition.getCompositionId();
516         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
517         automationComposition.setCompositionId(compositionId);
518         var supervisionAcHandler = mock(SupervisionAcHandler.class);
519         var participantProvider = mock(ParticipantProvider.class);
520         var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
521         var encryptionUtils = mock(EncryptionUtils.class);
522
523         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
524                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, acRuntimeParameterGroup,
525                 encryptionUtils);
526
527         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
528                 .thenReturn(automationComposition);
529
530         var wrongCompositionId = UUID.randomUUID();
531         var instanceId = automationComposition.getInstanceId();
532         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
533                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
534
535         automationComposition.setDeployState(DeployState.UNDEPLOYED);
536         automationComposition.setLockState(LockState.NONE);
537         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
538         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
539         verify(supervisionAcHandler).delete(any(), any());
540     }
541
542     @Test
543     void testInstantiationDeleteError() {
544         var automationComposition =
545                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
546         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
547         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
548         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
549         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
550         assertThatDeleteThrownBy(automationComposition, DeployState.DELETING, LockState.NONE);
551     }
552
553     @Test
554     void testRollbackFailure() {
555         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
556         var compositionId = acDefinition.getCompositionId();
557         var automationComposition =
558             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Rollback");
559         automationComposition.setCompositionId(compositionId);
560         automationComposition.setInstanceId(UUID.randomUUID());
561         automationComposition.setDeployState(DeployState.MIGRATION_REVERTING);
562         automationComposition.setCompositionTargetId(UUID.randomUUID());
563
564         var acProvider = mock(AutomationCompositionProvider.class);
565         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
566             .thenReturn(automationComposition);
567         var rollbackRecord = new JpaAutomationCompositionRollback();
568         when(acProvider.getAutomationCompositionRollback(any(UUID.class))).thenReturn(rollbackRecord.toAuthorative());
569
570         final var acDefinitionProvider = mock(AcDefinitionProvider.class);
571         final var supervisionAcHandler = mock(SupervisionAcHandler.class);
572         final var participantProvider = mock(ParticipantProvider.class);
573         final var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
574         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
575             new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
576             encryptionUtils);
577
578         var instanceId = automationComposition.getInstanceId();
579         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(instanceId));
580
581         // DeployState != MIGRATION_REVERTING
582         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
583             .thenReturn(automationComposition);
584         when(acProvider.getAutomationCompositionRollback(any(UUID.class))).thenReturn(rollbackRecord.toAuthorative());
585
586         automationComposition.setDeployState(DeployState.DELETING);
587         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(instanceId));
588
589         // SubState != NONE
590         automationComposition.setDeployState(DeployState.DEPLOYED);
591         automationComposition.setSubState(SubState.PREPARING);
592         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(instanceId));
593
594         // StateChangeResult != NO_ERROR
595         automationComposition.setSubState(SubState.NONE);
596         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
597         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(instanceId));
598
599         verify(acProvider, never()).updateAutomationComposition(any());
600     }
601
602     @Test
603     void testRollbackSuccess() {
604         final var acDefinitionProvider = mock(AcDefinitionProvider.class);
605         final var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
606         final var compositionId = acDefinition.getCompositionId();
607
608         var automationComposition =
609             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Rollback");
610         automationComposition.setInstanceId(UUID.randomUUID());
611         automationComposition.setCompositionId(compositionId);
612         automationComposition.setDeployState(DeployState.DEPLOYED);
613         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
614         automationComposition.setSubState(SubState.NONE);
615         automationComposition.setCompositionTargetId(UUID.randomUUID());
616
617         var acProvider = mock(AutomationCompositionProvider.class);
618         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
619             .thenReturn(automationComposition);
620         final var supervisionAcHandler = mock(SupervisionAcHandler.class);
621         final var participantProvider = mock(ParticipantProvider.class);
622         final var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
623         final var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider,
624             acDefinitionProvider, new AcInstanceStateResolver(), supervisionAcHandler,
625             participantProvider, new AcRuntimeParameterGroup(), encryptionUtils);
626
627         var rollbackRecord = new JpaAutomationCompositionRollback();
628         rollbackRecord.setCompositionId(automationComposition.getCompositionId().toString());
629
630         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
631             .thenReturn(automationComposition);
632         when(acProvider.getAutomationCompositionRollback(any(UUID.class))).thenReturn(rollbackRecord.toAuthorative());
633
634         instantiationProvider.rollback(automationComposition.getInstanceId());
635
636         verify(acProvider).updateAutomationComposition(automationComposition);
637         assertEquals(DeployState.MIGRATION_REVERTING, automationComposition.getDeployState());
638     }
639
640     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
641             LockState lockState) {
642         automationComposition.setDeployState(deployState);
643         automationComposition.setLockState(lockState);
644         var acProvider = mock(AutomationCompositionProvider.class);
645         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
646                 .thenReturn(automationComposition);
647         var acDefinitionProvider = mock(AcDefinitionProvider.class);
648         var acRuntimeParamaterGroup = mock(AcRuntimeParameterGroup.class);
649
650         var instantiationProvider =
651                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
652                         new AcInstanceStateResolver(), null, mock(ParticipantProvider.class),
653                         acRuntimeParamaterGroup, null);
654
655         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
656         var compositionId = acDefinition.getCompositionId();
657         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
658         automationComposition.setCompositionId(compositionId);
659
660         var instanceId = automationComposition.getInstanceId();
661         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
662                 .hasMessageStartingWith(String.format(DELETE_BAD_REQUEST));
663     }
664
665     @Test
666     void testCreateAutomationCompositions_NoDuplicates() {
667         var acDefinitionProvider = mock(AcDefinitionProvider.class);
668         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
669         var compositionId = acDefinition.getCompositionId();
670         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
671
672         var automationCompositionCreate =
673                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
674         automationCompositionCreate.setCompositionId(compositionId);
675         automationCompositionCreate.setInstanceId(UUID.randomUUID());
676
677         var acProvider = mock(AutomationCompositionProvider.class);
678         when(acProvider.createAutomationComposition(automationCompositionCreate))
679                 .thenReturn(automationCompositionCreate);
680         var participantProvider = mock(ParticipantProvider.class);
681         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
682
683         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
684                 null, null, participantProvider,
685                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
686
687         var instantiationResponse = instantiationProvider.createAutomationComposition(
688                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
689         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
690
691         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
692                 .thenReturn(Optional.of(automationCompositionCreate));
693
694         assertThatThrownBy(
695                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
696                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
697     }
698
699     @Test
700     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
701         var acDefinitionProvider = mock(AcDefinitionProvider.class);
702         var participantProvider = mock(ParticipantProvider.class);
703         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
704         var compositionId = acDefinition.getCompositionId();
705         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
706         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
707                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
708         automationComposition.setCompositionId(compositionId);
709
710         var acProvider = mock(AutomationCompositionProvider.class);
711         var encryptionUtils = mock(EncryptionUtils.class);
712         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
713                 participantProvider, CommonTestData.getTestParamaterGroup(), encryptionUtils);
714
715         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
716                 .hasMessageContaining(AC_ELEMENT_NAME_NOT_FOUND);
717
718         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
719                 .thenReturn(automationComposition);
720
721         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
722                 .hasMessageContaining(AC_ELEMENT_NAME_NOT_FOUND);
723     }
724
725     @Test
726     void testAcDefinitionNotFound() {
727         var automationComposition = InstantiationUtils
728                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
729
730         var acProvider = mock(AutomationCompositionProvider.class);
731         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
732                 .thenReturn(automationComposition);
733         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
734                 null, null, null,
735                 mock(AcRuntimeParameterGroup.class), null);
736
737         var compositionId = automationComposition.getCompositionId();
738         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
739                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
740
741         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
742                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
743     }
744
745     @Test
746     void testCompositionIdDoNotMatch() {
747         var automationComposition = InstantiationUtils
748                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
749
750         var acProvider = mock(AutomationCompositionProvider.class);
751         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
752                 .thenReturn(automationComposition);
753         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
754                 null, null, null,
755                 mock(AcRuntimeParameterGroup.class), null);
756
757         var compositionId = automationComposition.getCompositionId();
758         var wrongCompositionId = UUID.randomUUID();
759         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
760                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
761
762         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
763                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
764
765         assertThatThrownBy(
766                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
767                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
768         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
769                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
770                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
771
772         var compositionTargetId = UUID.randomUUID();
773         automationComposition.setCompositionTargetId(compositionTargetId);
774         assertThatThrownBy(
775                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
776                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
777
778         var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
779         assertThat(result).isNotNull();
780     }
781
782     @Test
783     void testCompositionNotPrimed() {
784         var acDefinitionProvider = mock(AcDefinitionProvider.class);
785         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
786         var compositionId = acDefinition.getCompositionId();
787         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
788         var acProvider = mock(AutomationCompositionProvider.class);
789         var provider =
790                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
791                         null, null);
792
793         var automationComposition =
794                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
795         automationComposition.setCompositionId(compositionId);
796         var message = """
797                       "AutomationComposition" INVALID, item has status INVALID
798                         item "ServiceTemplate.state" value "COMMISSIONED" INVALID, Commissioned automation composition \
799                       definition not primed
800                       """;
801
802         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
803                 .hasMessageMatching(message);
804     }
805
806     @Test
807     void testCompositionInstanceState() {
808         var acDefinitionProvider = mock(AcDefinitionProvider.class);
809         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
810         var compositionId = acDefinition.getCompositionId();
811         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
812
813         var automationComposition = InstantiationUtils
814                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
815         var instanceId = UUID.randomUUID();
816         automationComposition.setCompositionId(compositionId);
817         automationComposition.setInstanceId(instanceId);
818         var acProvider = mock(AutomationCompositionProvider.class);
819         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
820
821         var supervisionAcHandler = mock(SupervisionAcHandler.class);
822         var participantProvider = mock(ParticipantProvider.class);
823         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
824                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
825                 mock(AcRuntimeParameterGroup.class), null);
826
827         var acInstanceStateUpdate = new AcInstanceStateUpdate();
828         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
829         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
830         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
831         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
832                 any(AutomationCompositionDefinition.class));
833
834         automationComposition.setDeployState(DeployState.DEPLOYED);
835         automationComposition.setLockState(LockState.LOCKED);
836         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
837         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
838         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
839                 any(AutomationCompositionDefinition.class));
840
841         automationComposition.setDeployState(DeployState.DEPLOYED);
842         automationComposition.setLockState(LockState.LOCKED);
843         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
844         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
845         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
846         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
847                 any(AutomationCompositionDefinition.class));
848
849         automationComposition.setDeployState(DeployState.DEPLOYED);
850         automationComposition.setLockState(LockState.UNLOCKED);
851         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
852         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
853         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
854         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
855
856         automationComposition.setDeployState(DeployState.UNDEPLOYED);
857         automationComposition.setLockState(LockState.NONE);
858         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
859         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
860         acInstanceStateUpdate.setSubOrder(SubOrder.PREPARE);
861         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
862         verify(supervisionAcHandler).prepare(any(AutomationComposition.class), any());
863
864         automationComposition.setDeployState(DeployState.DEPLOYED);
865         automationComposition.setLockState(LockState.LOCKED);
866         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
867         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
868         acInstanceStateUpdate.setSubOrder(SubOrder.REVIEW);
869         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
870         verify(supervisionAcHandler).review(any(AutomationComposition.class));
871     }
872 }