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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2022 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.Mockito.mock;
  27 import static org.mockito.Mockito.verify;
  28 import static org.mockito.Mockito.when;
  29 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  30
  31 import java.util.List;
  32 import java.util.Optional;
  33 import java.util.UUID;
  34 import org.junit.jupiter.api.BeforeAll;
  35 import org.junit.jupiter.api.Test;
  36 import org.mockito.Mockito;
  37 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionHandler;
  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.AutomationComposition;
  41 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
  42 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
  43 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationUpdate;
  44 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  45 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  46 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  47 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  49 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  50
  51 /**
  52  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
  53  *
  54  */
  55 class AutomationCompositionInstantiationProviderTest {
  56     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  57     private static final String AC_INSTANTIATION_UPDATE_JSON =
  58             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  59     private static final String AC_INSTANTIATION_CHANGE_STATE_JSON = "src/test/resources/rest/acm/PassiveCommand.json";
  60     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  61             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  62     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  63             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  64     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
  65     private static final String ORDERED_STATE_INVALID = "ordered state invalid or not specified on command";
  66     private static final String AC_ELEMENT_NAME_NOT_FOUND =
  67             "\"AutomationComposition\" INVALID, item has status INVALID\n"
  68                     + "  \"entry PMSHInstance0AcElementNotFound\" INVALID, item has status INVALID\n"
  69                     + "    \"entry org.onap.domain.pmsh.DCAEMicroservice\" INVALID, Not found\n"
  70                     + "    \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
  71                     + " INVALID, Not found\n";
  72     private static final String AC_DEFINITION_NOT_FOUND = "\"AutomationComposition\" INVALID, item has status INVALID\n"
  73             + "  item \"ServiceTemplate\" value \"\" INVALID,"
  74             + " Commissioned automation composition definition not found\n";
  75     private static final String DO_NOT_MATCH = " do not match with ";
  76
  77     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  78
  79     @BeforeAll
  80     public static void setUpBeforeClass() {
  81         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  82         var jpa =
  83                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
  84         serviceTemplate = jpa.toAuthorative();
  85     }
  86
  87     @Test
  88     void testInstantiationCrud() throws AutomationCompositionException {
  89         var participantProvider = Mockito.mock(ParticipantProvider.class);
  90         var participants = CommonTestData.createParticipants();
  91         when(participantProvider.getParticipants()).thenReturn(participants);
  92
  93         var acDefinitionProvider = mock(AcDefinitionProvider.class);
  94         var compositionId = UUID.randomUUID();
  95         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(serviceTemplate));
  96         var supervisionHandler = mock(SupervisionHandler.class);
  97         var acProvider = mock(AutomationCompositionProvider.class);
  98         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
  99                 participantProvider, acDefinitionProvider);
 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(automationCompositionCreate.getName(),
 113                 automationCompositionCreate.getVersion())).thenReturn(List.of(automationCompositionCreate));
 114
 115         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(
 116                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion());
 117         assertThat(automationCompositionCreate)
 118                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 119
 120         var instanceUpdate = new InstantiationUpdate();
 121         var automationCompositionUpdate =
 122                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 123         automationCompositionUpdate.setCompositionId(compositionId);
 124         instanceUpdate.setElements(automationCompositionUpdate.getElements());
 125         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 126                 .thenReturn(automationCompositionUpdate);
 127         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 128                 .thenReturn(automationCompositionUpdate);
 129
 130         instantiationResponse =
 131                 instantiationProvider.updateAutomationComposition(automationCompositionUpdate.getCompositionId(),
 132                         automationCompositionUpdate.getInstanceId(), instanceUpdate);
 133         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 134
 135         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 136
 137         var instanceUpdateCommand = new InstantiationUpdate();
 138         var instantiationCommand =
 139                 InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON);
 140         instanceUpdateCommand.setInstantiationCommand(instantiationCommand);
 141         instantiationResponse =
 142                 instantiationProvider.updateAutomationComposition(automationCompositionUpdate.getCompositionId(),
 143                         automationCompositionUpdate.getInstanceId(), instanceUpdateCommand);
 144         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 145
 146         verify(supervisionHandler).triggerAutomationCompositionSupervision(automationCompositionUpdate);
 147
 148         // in order to delete a automationComposition the state must be UNINITIALISED
 149         automationCompositionCreate.setState(AutomationCompositionState.UNINITIALISED);
 150
 151         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
 152                 .thenReturn(automationCompositionUpdate);
 153         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
 154                 automationCompositionCreate.getInstanceId());
 155
 156         verify(acProvider).deleteAutomationComposition(automationCompositionCreate.getInstanceId());
 157     }
 158
 159     @Test
 160     void testInstantiationDelete() {
 161         var automationComposition =
 162                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 163
 164         var participantProvider = Mockito.mock(ParticipantProvider.class);
 165         var acProvider = mock(AutomationCompositionProvider.class);
 166         var supervisionHandler = mock(SupervisionHandler.class);
 167         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 168
 169         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 170                 participantProvider, acDefinitionProvider);
 171
 172         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 173                 .thenReturn(automationComposition);
 174
 175         var wrongCompositionId = UUID.randomUUID();
 176         var instanceId = automationComposition.getInstanceId();
 177         var compositionId = automationComposition.getCompositionId();
 178         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 179                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 180
 181         for (var state : AutomationCompositionState.values()) {
 182             if (!AutomationCompositionState.UNINITIALISED.equals(state)) {
 183                 assertThatDeleteThrownBy(automationComposition, state);
 184             }
 185         }
 186         automationComposition.setState(AutomationCompositionState.UNINITIALISED);
 187         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 188
 189         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 190     }
 191
 192     private void assertThatDeleteThrownBy(AutomationComposition automationComposition,
 193             AutomationCompositionState state) {
 194         automationComposition.setState(state);
 195         var participantProvider = Mockito.mock(ParticipantProvider.class);
 196         var acProvider = mock(AutomationCompositionProvider.class);
 197         var supervisionHandler = mock(SupervisionHandler.class);
 198         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 199
 200         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 201                 participantProvider, acDefinitionProvider);
 202
 203         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 204                 .thenReturn(automationComposition);
 205
 206         var compositionId = automationComposition.getCompositionId();
 207         var instanceId = automationComposition.getInstanceId();
 208         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 209                 .hasMessageMatching(String.format(DELETE_BAD_REQUEST, state));
 210     }
 211
 212     @Test
 213     void testCreateAutomationCompositions_NoDuplicates() {
 214         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 215         var compositionId = UUID.randomUUID();
 216         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(serviceTemplate));
 217
 218         var automationCompositionCreate =
 219                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 220         automationCompositionCreate.setCompositionId(compositionId);
 221         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 222
 223         var acProvider = mock(AutomationCompositionProvider.class);
 224         when(acProvider.createAutomationComposition(automationCompositionCreate))
 225                 .thenReturn(automationCompositionCreate);
 226
 227         var participantProvider = Mockito.mock(ParticipantProvider.class);
 228         var supervisionHandler = mock(SupervisionHandler.class);
 229
 230         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 231                 participantProvider, acDefinitionProvider);
 232
 233         var instantiationResponse = instantiationProvider.createAutomationComposition(
 234                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 235         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 236
 237         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 238                 .thenReturn(Optional.of(automationCompositionCreate));
 239
 240         assertThatThrownBy(
 241                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 242                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 243     }
 244
 245     @Test
 246     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 247         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 248         var compositionId = UUID.randomUUID();
 249         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(serviceTemplate));
 250         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 251                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 252         automationComposition.setCompositionId(compositionId);
 253
 254         var acProvider = mock(AutomationCompositionProvider.class);
 255         var participantProvider = mock(ParticipantProvider.class);
 256         var supervisionHandler = mock(SupervisionHandler.class);
 257         var provider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 258                 participantProvider, acDefinitionProvider);
 259
 260         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 261                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 262
 263         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 264                 .thenReturn(automationComposition);
 265         var instanceUpdate = new InstantiationUpdate();
 266         instanceUpdate.setElements(automationComposition.getElements());
 267
 268         var instanceId = automationComposition.getInstanceId();
 269         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, instanceId, instanceUpdate))
 270                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 271     }
 272
 273     @Test
 274     void testCreateAutomationCompositions_CommissionedAcNotFound() {
 275         var automationComposition = InstantiationUtils
 276                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 277
 278         var participantProvider = Mockito.mock(ParticipantProvider.class);
 279         var acProvider = mock(AutomationCompositionProvider.class);
 280         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 281                 .thenReturn(automationComposition);
 282         var supervisionHandler = mock(SupervisionHandler.class);
 283         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 284         var provider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 285                 participantProvider, acDefinitionProvider);
 286
 287         var compositionId = automationComposition.getCompositionId();
 288         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 289                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 290
 291         var instanceUpdate = new InstantiationUpdate();
 292         instanceUpdate.setElements(automationComposition.getElements());
 293         var instanceId = automationComposition.getInstanceId();
 294         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, instanceId, instanceUpdate))
 295                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 296
 297         var wrongCompositionId = UUID.randomUUID();
 298         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 299                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 300
 301         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, instanceId, instanceUpdate))
 302                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 303     }
 304
 305     @Test
 306     void testIssueAutomationCompositionCommand_OrderedStateInvalid() {
 307         var participantProvider = Mockito.mock(ParticipantProvider.class);
 308         var acProvider = mock(AutomationCompositionProvider.class);
 309         var supervisionHandler = mock(SupervisionHandler.class);
 310         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 311         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 312                 participantProvider, acDefinitionProvider);
 313         var instanceUpdate = new InstantiationUpdate();
 314         instanceUpdate.setInstantiationCommand(new InstantiationCommand());
 315         var automationComposition = InstantiationUtils
 316                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 317         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 318                 .thenReturn(automationComposition);
 319
 320         var compositionId = automationComposition.getCompositionId();
 321         var instanceId = automationComposition.getInstanceId();
 322         assertThatThrownBy(
 323                 () -> instantiationProvider.updateAutomationComposition(compositionId, instanceId, instanceUpdate))
 324                         .hasMessageMatching(ORDERED_STATE_INVALID);
 325     }
 326 }