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