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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2024 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.clamp.models.acm.persistence.provider;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.Mockito.mock;
  27 import static org.mockito.Mockito.verify;
  28 import static org.mockito.Mockito.when;
  29
  30 import java.util.HashMap;
  31 import java.util.List;
  32 import java.util.Map;
  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.mockito.Mockito;
  38 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  40 import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
  41 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  42 import org.onap.policy.clamp.models.acm.document.concepts.DocToscaServiceTemplate;
  43 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationCompositionDefinition;
  44 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaNodeTemplateState;
  45 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionDefinitionRepository;
  46 import org.onap.policy.clamp.models.acm.persistence.repository.NodeTemplateStateRepository;
  47 import org.onap.policy.clamp.models.acm.utils.CommonTestData;
  48 import org.onap.policy.clamp.models.acm.utils.TimestampHelper;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaTopologyTemplate;
  52 import org.springframework.data.domain.Example;
  53
  54 class AcDefinitionProviderTest {
  55
  56     private static final String TOSCA_SERVICE_TEMPLATE_YAML = "clamp/acm/pmsh/funtional-pmsh-usecase.yaml";
  57     private static final String TOSCA_SERVICE_TEMPLATE_YAML_PROP =
  58             "clamp/acm/test/tosca-template-additional-properties.yaml";
  59
  60     private static final String ELEMENT_NAME = "org.onap.policy.clamp.acm.AutomationCompositionElement";
  61     private static final String INVALID_ELEMENT_NAME = "dummyElement";
  62     private static final String NODE_TYPE = "org.onap.policy.clamp.acm.AutomationComposition";
  63     private static final String INVALID_NODE_TYPE = "dummyNodeTypeName";
  64
  65     private static ToscaServiceTemplate inputServiceTemplate;
  66
  67     @Test
  68     void testBadRequest() {
  69         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
  70         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
  71
  72         var compositionId = UUID.randomUUID();
  73         var serviceTemplate = new ToscaServiceTemplate();
  74         serviceTemplate.setToscaTopologyTemplate(new ToscaTopologyTemplate());
  75         serviceTemplate.getToscaTopologyTemplate().setNodeTemplates(new HashMap<>());
  76         assertThatThrownBy(() -> acDefinitionProvider.updateServiceTemplate(compositionId, serviceTemplate,
  77                 "ElementName", "CompositionName"))
  78                 .hasMessageMatching("NodeTemplate with element type ElementName must exist!");
  79
  80         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplate);
  81         var acmDefinition = getAcDefinition(docServiceTemplate);
  82         assertThatThrownBy(() -> acDefinitionProvider.updateAcDefinition(acmDefinition, "CompositionName"))
  83                 .hasMessageStartingWith("\"AutomationCompositionDefinition\" INVALID, item has status INVALID");
  84
  85         assertThatThrownBy(() -> acDefinitionProvider.updateAcDefinitionState(compositionId, AcTypeState.PRIMED,
  86                 StateChangeResult.NO_ERROR, false))
  87                 .hasMessageStartingWith("update of Automation Composition Definition");
  88     }
  89
  90     @BeforeAll
  91     static void loadServiceTemplate() {
  92         inputServiceTemplate = CommonTestData.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  93     }
  94
  95     @Test
  96     void testDocCopyCompare() {
  97
  98         var inputServiceTemplateProperties = CommonTestData.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML_PROP);
  99         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplateProperties);
 100         var docServiceTemplateCopy = new DocToscaServiceTemplate(docServiceTemplate);
 101
 102         assertThat(docServiceTemplate.compareTo(docServiceTemplateCopy)).isEqualByComparingTo(0);
 103         assertThat(docServiceTemplate.compareToWithoutEntities(docServiceTemplateCopy)).isZero();
 104
 105         var acmDefinition = getAcDefinition(docServiceTemplate);
 106         var acmDefinitionCopy = getAcDefinition(docServiceTemplateCopy);
 107
 108         assertThat(acmDefinition.getServiceTemplate().getName())
 109                 .isEqualTo(acmDefinitionCopy.getServiceTemplate().getName());
 110
 111     }
 112
 113     @Test
 114     void testCreateServiceTemplate() {
 115         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplate);
 116         var acmDefinition = getAcDefinition(docServiceTemplate);
 117
 118         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 119         when(acmDefinitionRepository.save(any(JpaAutomationCompositionDefinition.class)))
 120                 .thenReturn(new JpaAutomationCompositionDefinition(acmDefinition));
 121
 122         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 123         var result = acDefinitionProvider
 124                 .createAutomationCompositionDefinition(inputServiceTemplate, ELEMENT_NAME, NODE_TYPE);
 125
 126         assertThat(result.getServiceTemplate()).isEqualTo(docServiceTemplate.toAuthorative());
 127         assertThat(result.getServiceTemplate().getMetadata()).isNotNull();
 128     }
 129
 130     @Test
 131     void testToscaWithInvalidElement() {
 132         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 133
 134         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 135
 136         assertThatThrownBy(() -> acDefinitionProvider
 137                 .createAutomationCompositionDefinition(inputServiceTemplate, INVALID_ELEMENT_NAME, NODE_TYPE))
 138                 .hasMessage("NodeTemplate with element type " + INVALID_ELEMENT_NAME + " must exist!");
 139     }
 140
 141     @Test
 142     void testToscaWithInvalidNodeType() {
 143         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 144
 145         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 146
 147         assertThatThrownBy(() -> acDefinitionProvider
 148                 .createAutomationCompositionDefinition(inputServiceTemplate, ELEMENT_NAME, INVALID_NODE_TYPE))
 149                 .hasMessageContaining("NodeTemplate with type " + INVALID_NODE_TYPE + " must exist!");
 150     }
 151
 152     @Test
 153     void testCreateServiceTemplateWithMetadata() {
 154         inputServiceTemplate.setMetadata(new HashMap<>());
 155         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplate);
 156         var acmDefinition = getAcDefinition(docServiceTemplate);
 157
 158         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 159         when(acmDefinitionRepository.save(any(JpaAutomationCompositionDefinition.class)))
 160             .thenReturn(new JpaAutomationCompositionDefinition(acmDefinition));
 161
 162         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 163         inputServiceTemplate.setMetadata(new HashMap<>());
 164         var result = acDefinitionProvider
 165                 .createAutomationCompositionDefinition(inputServiceTemplate, ELEMENT_NAME, NODE_TYPE);
 166
 167         assertThat(result.getServiceTemplate()).isEqualTo(docServiceTemplate.toAuthorative());
 168         assertThat(result.getServiceTemplate().getMetadata()).isNotNull();
 169     }
 170
 171     @Test
 172     void testUpdateServiceTemplate() {
 173         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 174         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 175         acDefinitionProvider.updateServiceTemplate(UUID.randomUUID(), inputServiceTemplate, ELEMENT_NAME, NODE_TYPE);
 176         verify(acmDefinitionRepository).save(any(JpaAutomationCompositionDefinition.class));
 177     }
 178
 179     @Test
 180     void testUpdateAcDefinition() {
 181         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 182         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 183         var acmDefinition = getAcDefinition(new DocToscaServiceTemplate(inputServiceTemplate));
 184         acDefinitionProvider.updateAcDefinition(acmDefinition, NODE_TYPE);
 185         verify(acmDefinitionRepository).save(any(JpaAutomationCompositionDefinition.class));
 186     }
 187
 188     @Test
 189     void testUpdateAcDefinitionState() {
 190         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 191         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 192         var acmDefinition = getAcDefinition(new DocToscaServiceTemplate(inputServiceTemplate));
 193         acmDefinition.setState(AcTypeState.PRIMING);
 194         var jpa = new JpaAutomationCompositionDefinition(acmDefinition);
 195         when(acmDefinitionRepository.findById(acmDefinition.getCompositionId().toString()))
 196             .thenReturn(Optional.of(jpa));
 197         acDefinitionProvider.updateAcDefinitionState(acmDefinition.getCompositionId(), AcTypeState.PRIMED,
 198             StateChangeResult.NO_ERROR, false);
 199         verify(acmDefinitionRepository).save(jpa);
 200     }
 201
 202     @Test
 203     void testUpdateAcDefinitionElement() {
 204         var nodeTemplateState = new NodeTemplateState();
 205         nodeTemplateState.setNodeTemplateId(new ToscaConceptIdentifier("name", "1.0.0"));
 206         nodeTemplateState.setNodeTemplateStateId(UUID.randomUUID());
 207         nodeTemplateState.setState(AcTypeState.PRIMED);
 208         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 209         var acDefinitionProvider = new AcDefinitionProvider(null, nodeTemplateStateRepository);
 210         acDefinitionProvider.updateAcDefinitionElement(nodeTemplateState, UUID.randomUUID());
 211         verify(nodeTemplateStateRepository).save(any(JpaNodeTemplateState.class));
 212     }
 213
 214     @Test
 215     void testGetAcDefinition() {
 216         var jpa = new JpaAutomationCompositionDefinition();
 217         jpa.fromAuthorative(getAcDefinition(new DocToscaServiceTemplate(inputServiceTemplate)));
 218         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 219         when(acmDefinitionRepository.findById(jpa.getCompositionId())).thenReturn(Optional.of(jpa));
 220         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 221         var result = acDefinitionProvider.getAcDefinition(UUID.fromString(jpa.getCompositionId()));
 222         assertThat(result).isNotNull();
 223     }
 224
 225     @Test
 226     void testGetAcDefinitionNotFound() {
 227         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 228         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 229         var compositionId = UUID.randomUUID();
 230         assertThatThrownBy(() -> acDefinitionProvider.getAcDefinition(compositionId))
 231                 .hasMessage("Get serviceTemplate \"" + compositionId + "\" failed, serviceTemplate does not exist");
 232     }
 233
 234     @Test
 235     void testFindAcDefinition() {
 236         var jpa = new JpaAutomationCompositionDefinition();
 237         jpa.fromAuthorative(getAcDefinition(new DocToscaServiceTemplate(inputServiceTemplate)));
 238         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 239         when(acmDefinitionRepository.findById(jpa.getCompositionId())).thenReturn(Optional.of(jpa));
 240         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 241         var compositionId = UUID.fromString(jpa.getCompositionId());
 242         var result = acDefinitionProvider.findAcDefinition(compositionId);
 243         assertThat(result).isNotEmpty();
 244     }
 245
 246     @Test
 247     void getAllAcDefinitionsInTransition() {
 248         var acDefinition = getAcDefinition(new DocToscaServiceTemplate(inputServiceTemplate));
 249         acDefinition.setState(AcTypeState.PRIMING);
 250         var jpa = new JpaAutomationCompositionDefinition();
 251         jpa.fromAuthorative(acDefinition);
 252         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 253         when(acmDefinitionRepository.findByStateIn(List.of(AcTypeState.PRIMING, AcTypeState.DEPRIMING)))
 254             .thenReturn(List.of(jpa));
 255         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 256         var result = acDefinitionProvider.getAllAcDefinitionsInTransition();
 257         assertThat(result).isNotEmpty();
 258     }
 259
 260     @Test
 261     void testDeleteAcDefintion() {
 262         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplate);
 263         var acmDefinition = getAcDefinition(docServiceTemplate);
 264
 265         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 266         when(acmDefinitionRepository.findById(acmDefinition.getCompositionId().toString()))
 267                 .thenReturn(Optional.of(new JpaAutomationCompositionDefinition(acmDefinition)));
 268
 269         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 270         var result = acDefinitionProvider.deleteAcDefintion(acmDefinition.getCompositionId());
 271
 272         assertThat(result).isEqualTo(docServiceTemplate.toAuthorative());
 273     }
 274
 275     @Test
 276     void testDeleteServiceTemplateEmpty() {
 277         var compositionId = UUID.randomUUID();
 278         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 279         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 280         assertThatThrownBy(() -> acDefinitionProvider.deleteAcDefintion(compositionId))
 281                 .hasMessage("delete of Automation Composition Definition \"" + compositionId
 282                         + "\" failed, Automation Composition Definition does not exist");
 283     }
 284
 285     @Test
 286     void testGetServiceTemplate() {
 287         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplate);
 288         var acmDefinition = getAcDefinition(docServiceTemplate);
 289         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 290         when(acmDefinitionRepository.findAll(Mockito.<Example<JpaAutomationCompositionDefinition>>any()))
 291                 .thenReturn(List.of(new JpaAutomationCompositionDefinition(acmDefinition)));
 292
 293         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 294         var result = acDefinitionProvider.getServiceTemplateList(inputServiceTemplate.getName(),
 295                 inputServiceTemplate.getVersion());
 296
 297         assertThat(result).hasSize(1);
 298         assertThat(result.get(0)).isEqualTo(acmDefinition.getServiceTemplate());
 299     }
 300
 301     @Test
 302     void testGetServiceTemplateNulls() {
 303         var docServiceTemplate = new DocToscaServiceTemplate(inputServiceTemplate);
 304         var acmDefinition = getAcDefinition(docServiceTemplate);
 305         var acmDefinitionRepository = mock(AutomationCompositionDefinitionRepository.class);
 306         when(acmDefinitionRepository.findAll(Mockito.<Example<JpaAutomationCompositionDefinition>>any()))
 307             .thenReturn(List.of(new JpaAutomationCompositionDefinition(acmDefinition)));
 308
 309         var acDefinitionProvider = new AcDefinitionProvider(acmDefinitionRepository, null);
 310         var result = acDefinitionProvider.getServiceTemplateList(null,
 311             inputServiceTemplate.getVersion());
 312
 313         assertThat(result).hasSize(1);
 314         assertThat(result.get(0)).isEqualTo(acmDefinition.getServiceTemplate());
 315
 316         result = acDefinitionProvider.getServiceTemplateList(inputServiceTemplate.getName(),
 317             null);
 318
 319         assertThat(result).hasSize(1);
 320         assertThat(result.get(0)).isEqualTo(acmDefinition.getServiceTemplate());
 321
 322         result = acDefinitionProvider.getServiceTemplateList(null,
 323             null);
 324
 325         assertThat(result).isEmpty();
 326     }
 327
 328     private AutomationCompositionDefinition getAcDefinition(DocToscaServiceTemplate docServiceTemplate) {
 329         var acmDefinition = new AutomationCompositionDefinition();
 330         acmDefinition.setCompositionId(UUID.randomUUID());
 331         acmDefinition.setState(AcTypeState.COMMISSIONED);
 332         acmDefinition.setLastMsg(TimestampHelper.now());
 333         acmDefinition.setServiceTemplate(docServiceTemplate.toAuthorative());
 334         var nodeTemplateState = new NodeTemplateState();
 335         nodeTemplateState.setNodeTemplateStateId(UUID.randomUUID());
 336         nodeTemplateState.setNodeTemplateId(new ToscaConceptIdentifier("name", "1.0.0"));
 337         nodeTemplateState.setState(AcTypeState.COMMISSIONED);
 338         nodeTemplateState.setParticipantId(UUID.randomUUID());
 339         acmDefinition.setElementStateMap(Map.of(nodeTemplateState.getNodeTemplateId().getName(), nodeTemplateState));
 340         return acmDefinition;
 341     }
 342 }