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.AutomationCompositionRuntimeException;
  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.concepts.AutomationCompositions;
  43 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationCommand;
  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 =
  57             "src/test/resources/rest/acm/AutomationCompositions.json";
  58     private static final String AC_INSTANTIATION_UPDATE_JSON =
  59             "src/test/resources/rest/acm/AutomationCompositionsUpdate.json";
  60     private static final String AC_INSTANTIATION_CHANGE_STATE_JSON = "src/test/resources/rest/acm/PassiveCommand.json";
  61     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  62             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  63     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  64             "src/test/resources/rest/acm/AutomationCompositionsNotFound.json";
  65     private static final String AUTOMATION_COMPOSITION_NOT_FOUND = "Automation composition not found";
  66     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
  67     private static final String ORDERED_STATE_INVALID = "ordered state invalid or not specified on command";
  68     private static final String AC_ELEMENT_NAME_NOT_FOUND =
  69             "\"AutomationCompositions\" INVALID, item has status INVALID\n"
  70             + "  \"entry PMSHInstance0AcElementNotFound\" INVALID, item has status INVALID\n"
  71             + "    \"entry org.onap.domain.pmsh.DCAEMicroservice\" INVALID, Not found\n"
  72             + "    \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
  73             + " INVALID, Not found\n"
  74             + "    \"entry org.onap.domain.pmsh.PMSH_CDS_AutomationCompositionElement\" INVALID, Not found\n"
  75             + "  \"entry PMSHInstance1AcElementNotFound\" INVALID, item has status INVALID\n"
  76             + "    \"entry org.onap.domain.pmsh.DCAEMicroservice\" INVALID, Not found\n"
  77             + "    \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
  78             + " INVALID, Not found\n"
  79             + "    \"entry org.onap.domain.pmsh.PMSH_CDS_AutomationCompositionElement\" INVALID, Not found\n";
  80
  81     private static final String AC_DEFINITION_NOT_FOUND =
  82             "\"AutomationCompositions\" INVALID, item has status INVALID\n"
  83                     + "  item \"ServiceTemplate\" value \"\" INVALID,"
  84                     + " Commissioned automation composition definition not found\n"
  85                     + "  item \"ServiceTemplate\" value \"\" INVALID,"
  86                     + " Commissioned automation composition definition not found\n";
  87
  88     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  89
  90     @BeforeAll
  91     public static void setUpBeforeClass() {
  92         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  93         var jpa =
  94                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
  95         serviceTemplate = jpa.toAuthorative();
  96     }
  97
  98     @Test
  99     void testInstantiationCrud() throws Exception {
 100         var participantProvider = Mockito.mock(ParticipantProvider.class);
 101         var participants = CommonTestData.createParticipants();
 102         when(participantProvider.getParticipants()).thenReturn(participants);
 103
 104         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 105         var compositionId = UUID.randomUUID();
 106         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(serviceTemplate));
 107         var supervisionHandler = mock(SupervisionHandler.class);
 108         var acProvider = mock(AutomationCompositionProvider.class);
 109         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 110                 participantProvider, acDefinitionProvider);
 111         var automationCompositionsCreate =
 112                 InstantiationUtils.getAutomationCompositionsFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 113         for (var automationComposition : automationCompositionsCreate.getAutomationCompositionList()) {
 114             automationComposition.setCompositionId(compositionId);
 115         }
 116         var instantiationResponse = instantiationProvider.createAutomationCompositions(automationCompositionsCreate);
 117         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionsCreate);
 118
 119         verify(acProvider).saveAutomationCompositions(automationCompositionsCreate.getAutomationCompositionList());
 120
 121         for (var automationComposition : automationCompositionsCreate.getAutomationCompositionList()) {
 122             when(acProvider.getAutomationCompositions(automationComposition.getName(),
 123                     automationComposition.getVersion())).thenReturn(List.of(automationComposition));
 124
 125             var automationCompositionsGet = instantiationProvider
 126                     .getAutomationCompositions(automationComposition.getName(), automationComposition.getVersion());
 127             assertThat(automationCompositionsGet.getAutomationCompositionList()).hasSize(1);
 128             assertThat(automationComposition)
 129                     .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 130         }
 131
 132         var automationCompositionsUpdate =
 133                 InstantiationUtils.getAutomationCompositionsFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 134         for (var automationComposition : automationCompositionsUpdate.getAutomationCompositionList()) {
 135             automationComposition.setCompositionId(compositionId);
 136         }
 137
 138         instantiationResponse = instantiationProvider.updateAutomationCompositions(automationCompositionsUpdate);
 139         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionsUpdate);
 140
 141         verify(acProvider).saveAutomationCompositions(automationCompositionsUpdate.getAutomationCompositionList());
 142
 143         for (var automationComposition : automationCompositionsUpdate.getAutomationCompositionList()) {
 144             when(acProvider.findAutomationComposition(automationComposition.getKey().asIdentifier()))
 145                     .thenReturn(Optional.of(automationComposition));
 146             when(acProvider.findAutomationComposition(automationComposition.getName(),
 147                     automationComposition.getVersion())).thenReturn(Optional.of(automationComposition));
 148             when(acProvider.deleteAutomationComposition(automationComposition.getName(),
 149                     automationComposition.getVersion())).thenReturn(automationComposition);
 150         }
 151
 152         var instantiationCommand =
 153                 InstantiationUtils.getInstantiationCommandFromResource(AC_INSTANTIATION_CHANGE_STATE_JSON, "Crud");
 154         instantiationResponse = instantiationProvider.issueAutomationCompositionCommand(instantiationCommand);
 155         InstantiationUtils.assertInstantiationResponse(instantiationResponse, instantiationCommand);
 156
 157         verify(supervisionHandler)
 158                 .triggerAutomationCompositionSupervision(instantiationCommand.getAutomationCompositionIdentifierList());
 159
 160         // in order to delete a automationComposition the state must be UNINITIALISED
 161         automationCompositionsCreate.getAutomationCompositionList()
 162                 .forEach(ac -> ac.setState(AutomationCompositionState.UNINITIALISED));
 163         instantiationProvider.updateAutomationCompositions(automationCompositionsCreate);
 164
 165         for (AutomationComposition automationComposition : automationCompositionsCreate
 166                 .getAutomationCompositionList()) {
 167             instantiationProvider.deleteAutomationComposition(automationComposition.getName(),
 168                     automationComposition.getVersion());
 169
 170             verify(acProvider).deleteAutomationComposition(automationComposition.getName(),
 171                     automationComposition.getVersion());
 172         }
 173     }
 174
 175     @Test
 176     void testInstantiationDelete() throws Exception {
 177
 178         AutomationCompositions automationCompositions =
 179                 InstantiationUtils.getAutomationCompositionsFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 180
 181         AutomationComposition automationComposition0 = automationCompositions.getAutomationCompositionList().get(0);
 182         var participantProvider = Mockito.mock(ParticipantProvider.class);
 183         var acProvider = mock(AutomationCompositionProvider.class);
 184         var supervisionHandler = mock(SupervisionHandler.class);
 185         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 186
 187         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 188                 participantProvider, acDefinitionProvider);
 189
 190         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(automationComposition0.getName(),
 191                 automationComposition0.getVersion())).hasMessageMatching(AUTOMATION_COMPOSITION_NOT_FOUND);
 192
 193         for (AutomationCompositionState state : AutomationCompositionState.values()) {
 194             if (!AutomationCompositionState.UNINITIALISED.equals(state)) {
 195                 assertThatDeleteThrownBy(automationCompositions, state);
 196             }
 197         }
 198         automationComposition0.setState(AutomationCompositionState.UNINITIALISED);
 199
 200         for (AutomationComposition automationComposition : automationCompositions.getAutomationCompositionList()) {
 201             when(acProvider.findAutomationComposition(automationComposition.getName(),
 202                     automationComposition.getVersion())).thenReturn(Optional.of(automationComposition));
 203             when(acProvider.deleteAutomationComposition(automationComposition.getName(),
 204                     automationComposition.getVersion())).thenReturn(automationComposition);
 205
 206             instantiationProvider.deleteAutomationComposition(automationComposition.getName(),
 207                     automationComposition.getVersion());
 208         }
 209     }
 210
 211     private void assertThatDeleteThrownBy(AutomationCompositions automationCompositions,
 212             AutomationCompositionState state) throws Exception {
 213         AutomationComposition automationComposition = automationCompositions.getAutomationCompositionList().get(0);
 214         automationComposition.setState(state);
 215         var participantProvider = Mockito.mock(ParticipantProvider.class);
 216         var acProvider = mock(AutomationCompositionProvider.class);
 217         var supervisionHandler = mock(SupervisionHandler.class);
 218         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 219
 220         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 221                 participantProvider, acDefinitionProvider);
 222
 223         when(acProvider.findAutomationComposition(automationComposition.getName(), automationComposition.getVersion()))
 224                 .thenReturn(Optional.of(automationComposition));
 225
 226         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(automationComposition.getName(),
 227                 automationComposition.getVersion())).hasMessageMatching(String.format(DELETE_BAD_REQUEST, state));
 228     }
 229
 230     @Test
 231     void testCreateAutomationCompositions_NoDuplicates() throws Exception {
 232         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 233         var compositionId = UUID.randomUUID();
 234         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(serviceTemplate));
 235
 236         var automationCompositionsCreate =
 237                 InstantiationUtils.getAutomationCompositionsFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 238         for (var automationComposition : automationCompositionsCreate.getAutomationCompositionList()) {
 239             automationComposition.setCompositionId(compositionId);
 240         }
 241
 242         var acProvider = mock(AutomationCompositionProvider.class);
 243         var participantProvider = Mockito.mock(ParticipantProvider.class);
 244         var supervisionHandler = mock(SupervisionHandler.class);
 245
 246         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 247                 participantProvider, acDefinitionProvider);
 248
 249         var instantiationResponse =
 250                 instantiationProvider.createAutomationCompositions(automationCompositionsCreate);
 251         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionsCreate);
 252
 253         when(acProvider.findAutomationComposition(
 254                 automationCompositionsCreate.getAutomationCompositionList().get(0).getKey().asIdentifier()))
 255                         .thenReturn(Optional.of(automationCompositionsCreate.getAutomationCompositionList().get(0)));
 256
 257         assertThatThrownBy(() -> instantiationProvider.createAutomationCompositions(automationCompositionsCreate))
 258                 .hasMessageMatching(
 259                         automationCompositionsCreate.getAutomationCompositionList().get(0).getKey().asIdentifier()
 260                                 + " already defined");
 261     }
 262
 263     @Test
 264     void testCreateAutomationCompositions_CommissionedAcElementNotFound() throws Exception {
 265         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 266         var compositionId = UUID.randomUUID();
 267         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(serviceTemplate));
 268         var automationCompositions = InstantiationUtils.getAutomationCompositionsFromResource(
 269                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 270         for (var automationComposition : automationCompositions.getAutomationCompositionList()) {
 271             automationComposition.setCompositionId(compositionId);
 272         }
 273
 274         var acProvider = mock(AutomationCompositionProvider.class);
 275         var participantProvider = mock(ParticipantProvider.class);
 276         var supervisionHandler = mock(SupervisionHandler.class);
 277         var provider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 278                 participantProvider, acDefinitionProvider);
 279
 280         assertThatThrownBy(() -> provider.createAutomationCompositions(automationCompositions))
 281                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 282
 283         assertThatThrownBy(() -> provider.updateAutomationCompositions(automationCompositions))
 284                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 285     }
 286
 287     @Test
 288     void testCreateAutomationCompositions_CommissionedAcNotFound() throws Exception {
 289         AutomationCompositions automationCompositions = InstantiationUtils
 290                 .getAutomationCompositionsFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 291
 292         var participantProvider = Mockito.mock(ParticipantProvider.class);
 293         var acProvider = mock(AutomationCompositionProvider.class);
 294         var supervisionHandler = mock(SupervisionHandler.class);
 295         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 296         var provider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 297                 participantProvider, acDefinitionProvider);
 298
 299         assertThatThrownBy(() -> provider.createAutomationCompositions(automationCompositions))
 300                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 301
 302         assertThatThrownBy(() -> provider.updateAutomationCompositions(automationCompositions))
 303                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 304     }
 305
 306     @Test
 307     void testIssueAutomationCompositionCommand_OrderedStateInvalid() throws AutomationCompositionRuntimeException {
 308         var participantProvider = Mockito.mock(ParticipantProvider.class);
 309         var acProvider = mock(AutomationCompositionProvider.class);
 310         var supervisionHandler = mock(SupervisionHandler.class);
 311         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 312         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, supervisionHandler,
 313                 participantProvider, acDefinitionProvider);
 314         assertThatThrownBy(() -> instantiationProvider.issueAutomationCompositionCommand(new InstantiationCommand()))
 315                 .hasMessageMatching(ORDERED_STATE_INVALID);
 316     }
 317 }