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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2023 Nordix Foundation.
   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.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.mock;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  31
  32 import java.util.List;
  33 import java.util.Optional;
  34 import java.util.UUID;
  35 import org.junit.jupiter.api.BeforeAll;
  36 import org.junit.jupiter.api.Test;
  37 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
  38 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  39 import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
  40 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  41 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  42 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  43 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  44 import org.onap.policy.clamp.models.acm.concepts.LockState;
  45 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  46 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  47 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  48 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  49 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
  50 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  51 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  53 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  54
  55 /**
  56  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
  57  *
  58  */
  59 class AutomationCompositionInstantiationProviderTest {
  60     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  61     private static final String AC_INSTANTIATION_UPDATE_JSON =
  62             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  63
  64     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  65             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  66     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  67             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  68     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
  69
  70     private static final String AC_ELEMENT_NAME_NOT_FOUND =
  71             "\"AutomationComposition\" INVALID, item has status INVALID\n"
  72                     + "  \"entry PMSHInstance0AcElementNotFound\" INVALID, item has status INVALID\n"
  73                     + "    \"entry org.onap.domain.pmsh.DCAEMicroservice\" INVALID, Not found\n"
  74                     + "    \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
  75                     + " INVALID, Not found\n";
  76     private static final String AC_DEFINITION_NOT_FOUND = "\"AutomationComposition\" INVALID, item has status INVALID\n"
  77             + "  item \"ServiceTemplate\" value \"\" INVALID,"
  78             + " Commissioned automation composition definition not found\n";
  79     private static final String DO_NOT_MATCH = " do not match with ";
  80
  81     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  82
  83     @BeforeAll
  84     public static void setUpBeforeClass() {
  85         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  86         var jpa =
  87                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
  88         serviceTemplate = jpa.toAuthorative();
  89     }
  90
  91     @Test
  92     void testInstantiationCrud() throws AutomationCompositionException {
  93         var acDefinitionProvider = mock(AcDefinitionProvider.class);
  94         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
  95         var compositionId = acDefinition.getCompositionId();
  96         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
  97         var acProvider = mock(AutomationCompositionProvider.class);
  98         var instantiationProvider =
  99                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null);
 100         var automationCompositionCreate =
 101                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 102         automationCompositionCreate.setCompositionId(compositionId);
 103         when(acProvider.createAutomationComposition(automationCompositionCreate))
 104                 .thenReturn(automationCompositionCreate);
 105
 106         var instantiationResponse = instantiationProvider.createAutomationComposition(
 107                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 108         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 109
 110         verify(acProvider).createAutomationComposition(automationCompositionCreate);
 111
 112         when(acProvider.getAutomationCompositions(compositionId, automationCompositionCreate.getName(),
 113                 automationCompositionCreate.getVersion())).thenReturn(List.of(automationCompositionCreate));
 114
 115         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
 116                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion());
 117         assertThat(automationCompositionCreate)
 118                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 119
 120         var automationCompositionUpdate =
 121                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 122         automationCompositionUpdate.setCompositionId(compositionId);
 123         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 124                 .thenReturn(automationCompositionUpdate);
 125         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 126                 .thenReturn(automationCompositionUpdate);
 127
 128         instantiationResponse = instantiationProvider.updateAutomationComposition(
 129                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 130         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 131
 132         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 133
 134         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
 135                 .thenReturn(automationCompositionUpdate);
 136         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
 137                 automationCompositionCreate.getInstanceId());
 138
 139         verify(acProvider).deleteAutomationComposition(automationCompositionCreate.getInstanceId());
 140     }
 141
 142     @Test
 143     void testInstantiationDelete() {
 144         var automationComposition =
 145                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 146
 147         var acProvider = mock(AutomationCompositionProvider.class);
 148         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 149
 150         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider,
 151                 acDefinitionProvider, null, null);
 152
 153         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 154                 .thenReturn(automationComposition);
 155
 156         var wrongCompositionId = UUID.randomUUID();
 157         var instanceId = automationComposition.getInstanceId();
 158         var compositionId = automationComposition.getCompositionId();
 159         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 160                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 161
 162         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 163         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 164         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 165
 166         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 167         automationComposition.setLockState(LockState.NONE);
 168         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 169
 170         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 171     }
 172
 173     private void assertThatDeleteThrownBy(AutomationComposition automationComposition,
 174             DeployState deployState, LockState lockState) {
 175         automationComposition.setDeployState(deployState);
 176         automationComposition.setLockState(lockState);
 177         var acProvider = mock(AutomationCompositionProvider.class);
 178         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 179
 180         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider,
 181                 acDefinitionProvider, null, null);
 182
 183         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 184                 .thenReturn(automationComposition);
 185
 186         var compositionId = automationComposition.getCompositionId();
 187         var instanceId = automationComposition.getInstanceId();
 188         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 189                 .hasMessageMatching(String.format(DELETE_BAD_REQUEST, deployState));
 190     }
 191
 192     @Test
 193     void testCreateAutomationCompositions_NoDuplicates() {
 194         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 195         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 196         var compositionId = acDefinition.getCompositionId();
 197         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 198
 199         var automationCompositionCreate =
 200                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 201         automationCompositionCreate.setCompositionId(compositionId);
 202         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 203
 204         var acProvider = mock(AutomationCompositionProvider.class);
 205         when(acProvider.createAutomationComposition(automationCompositionCreate))
 206                 .thenReturn(automationCompositionCreate);
 207
 208         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider,
 209                 acDefinitionProvider, null, null);
 210
 211         var instantiationResponse = instantiationProvider.createAutomationComposition(
 212                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 213         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 214
 215         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 216                 .thenReturn(Optional.of(automationCompositionCreate));
 217
 218         assertThatThrownBy(
 219                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 220                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 221     }
 222
 223     @Test
 224     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 225         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 226         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 227         var compositionId = acDefinition.getCompositionId();
 228         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 229         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 230                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 231         automationComposition.setCompositionId(compositionId);
 232
 233         var acProvider = mock(AutomationCompositionProvider.class);
 234         var provider = new AutomationCompositionInstantiationProvider(acProvider,
 235                 acDefinitionProvider, null, null);
 236
 237         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 238                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 239
 240         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 241                 .thenReturn(automationComposition);
 242
 243         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 244                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 245     }
 246
 247     @Test
 248     void testAcDefinitionNotFound() {
 249         var automationComposition = InstantiationUtils
 250                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 251
 252         var acProvider = mock(AutomationCompositionProvider.class);
 253         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 254                 .thenReturn(automationComposition);
 255         var provider = new AutomationCompositionInstantiationProvider(acProvider,
 256                 mock(AcDefinitionProvider.class), null, null);
 257
 258         var compositionId = automationComposition.getCompositionId();
 259         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 260                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 261
 262         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 263                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 264     }
 265
 266     @Test
 267     void testCompositionIdDoNotMatch() {
 268         var automationComposition = InstantiationUtils
 269                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 270
 271         var acProvider = mock(AutomationCompositionProvider.class);
 272         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 273                 .thenReturn(automationComposition);
 274         var provider = new AutomationCompositionInstantiationProvider(acProvider,
 275                 mock(AcDefinitionProvider.class), null, null);
 276
 277         var compositionId = automationComposition.getCompositionId();
 278         var wrongCompositionId = UUID.randomUUID();
 279         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 280                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 281
 282         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 283                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 284
 285         assertThatThrownBy(
 286                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 287                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 288         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 289                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 290                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 291     }
 292
 293     @Test
 294     void testCompositionNotPrimed() {
 295         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 296         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 297         var compositionId = acDefinition.getCompositionId();
 298         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 299         var acProvider = mock(AutomationCompositionProvider.class);
 300         var provider =
 301                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null);
 302
 303         var automationComposition =
 304                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 305         automationComposition.setCompositionId(compositionId);
 306         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 307                 .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 308                         + "  item \"ServiceTemplate\" value \"COMMISSIONED\" INVALID,"
 309                         + " Commissioned automation composition definition not primed\n");
 310     }
 311
 312     @Test
 313     void testUpdateBadRequest() {
 314         var automationComposition = InstantiationUtils
 315                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 316
 317         var acProvider = mock(AutomationCompositionProvider.class);
 318         automationComposition.setDeployState(DeployState.DEPLOYED);
 319         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 320                 .thenReturn(automationComposition);
 321         var provider = new AutomationCompositionInstantiationProvider(acProvider,
 322                 mock(AcDefinitionProvider.class), null, null);
 323
 324         assertThatThrownBy(() -> provider.updateAutomationComposition(automationComposition.getCompositionId(),
 325                 automationComposition)).hasMessageMatching("Not allow to update for state in DEPLOYED");
 326     }
 327
 328     @Test
 329     void testCompositionInstanceState() {
 330         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 331         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 332         var compositionId = acDefinition.getCompositionId();
 333         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 334
 335         var automationComposition = InstantiationUtils
 336                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 337         var instanceId = UUID.randomUUID();
 338         automationComposition.setCompositionId(compositionId);
 339         automationComposition.setInstanceId(instanceId);
 340         var acProvider = mock(AutomationCompositionProvider.class);
 341         when(acProvider.getAutomationComposition(instanceId))
 342                 .thenReturn(automationComposition);
 343
 344         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 345         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 346                 new AcInstanceStateResolver(), supervisionAcHandler);
 347
 348         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 349         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 350         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 351         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 352         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 353                 any(AutomationCompositionDefinition.class));
 354
 355         automationComposition.setDeployState(DeployState.DEPLOYED);
 356         automationComposition.setLockState(LockState.LOCKED);
 357         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 358         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 359         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 360                 any(AutomationCompositionDefinition.class));
 361
 362         automationComposition.setDeployState(DeployState.DEPLOYED);
 363         automationComposition.setLockState(LockState.LOCKED);
 364         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 365         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 366         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 367         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 368                 any(AutomationCompositionDefinition.class));
 369
 370         automationComposition.setDeployState(DeployState.DEPLOYED);
 371         automationComposition.setLockState(LockState.UNLOCKED);
 372         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 373         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 374         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 375         verify(supervisionAcHandler).lock(any(AutomationComposition.class),
 376                 any(AutomationCompositionDefinition.class));
 377     }
 378 }