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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2021 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.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.eq;
  29 import static org.mockito.Mockito.mock;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.util.List;
  34 import java.util.Optional;
  35 import javax.persistence.EntityNotFoundException;
  36 import org.junit.jupiter.api.BeforeEach;
  37 import org.junit.jupiter.api.Test;
  38 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  40 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationComposition;
  41 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
  42 import org.onap.policy.clamp.models.acm.persistence.repository.ToscaNodeTemplateRepository;
  43 import org.onap.policy.clamp.models.acm.persistence.repository.ToscaNodeTemplatesRepository;
  44 import org.onap.policy.common.utils.coder.Coder;
  45 import org.onap.policy.common.utils.coder.StandardCoder;
  46 import org.onap.policy.common.utils.coder.YamlJsonTranslator;
  47 import org.onap.policy.common.utils.resources.ResourceUtils;
  48 import org.onap.policy.models.base.PfConceptKey;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  50 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  51 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  52 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  53 import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate;
  54
  55 class AutomationCompositionProviderTest {
  56
  57     private static final String LIST_IS_NULL = "automationCompositions is marked .*ull but is null";
  58     private static final String OBJECT_IS_NULL = "automationComposition is marked non-null but is null";
  59
  60     private static final String ID_NAME = "PMSHInstance1";
  61     private static final String ID_VERSION = "1.0.1";
  62     private static final String ID_NAME_NOT_EXTST = "not_exist";
  63     private static final String ID_NAME_NOT_VALID = "not_valid";
  64
  65     private static final Coder CODER = new StandardCoder();
  66     private static final String AUTOMATION_COMPOSITION_JSON =
  67         "src/test/resources/providers/TestAutomationCompositions.json";
  68     private static final String TOSCA_TEMPLATE_YAML = "examples/acm/PMSubscriptionHandling.yaml";
  69
  70     private static final YamlJsonTranslator yamlTranslator = new YamlJsonTranslator();
  71
  72     private AutomationCompositions inputAutomationCompositions;
  73     private List<JpaAutomationComposition> inputAutomationCompositionsJpa;
  74     private String originalJson = ResourceUtils.getResourceAsString(AUTOMATION_COMPOSITION_JSON);
  75
  76     @BeforeEach
  77     void beforeSetupDao() throws Exception {
  78         inputAutomationCompositions = CODER.decode(originalJson, AutomationCompositions.class);
  79         inputAutomationCompositionsJpa =
  80             ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
  81                 JpaAutomationComposition::new, "automation compositions");
  82     }
  83
  84     @Test
  85     void testAutomationCompositionsSave() throws Exception {
  86         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
  87         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
  88             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
  89
  90         assertThatThrownBy(() -> {
  91             automationCompositionProvider.saveAutomationCompositions(null);
  92         }).hasMessageMatching(LIST_IS_NULL);
  93
  94         when(automationCompositionRepository.saveAll(inputAutomationCompositionsJpa))
  95             .thenReturn(inputAutomationCompositionsJpa);
  96
  97         var createdAutomationCompositions = new AutomationCompositions();
  98         createdAutomationCompositions.setAutomationCompositionList(automationCompositionProvider
  99             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()));
 100
 101         assertEquals(inputAutomationCompositions, createdAutomationCompositions);
 102
 103         when(automationCompositionRepository.saveAll(any())).thenThrow(IllegalArgumentException.class);
 104
 105         assertThatThrownBy(() -> {
 106             automationCompositionProvider
 107                 .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList());
 108         }).hasMessageMatching("Error in save AutomationCompositions");
 109     }
 110
 111     @Test
 112     void testAutomationCompositionSave() throws Exception {
 113         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 114         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 115             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 116
 117         assertThatThrownBy(() -> {
 118             automationCompositionProvider.saveAutomationComposition(null);
 119         }).hasMessageMatching(OBJECT_IS_NULL);
 120
 121         when(automationCompositionRepository.save(inputAutomationCompositionsJpa.get(0)))
 122             .thenReturn(inputAutomationCompositionsJpa.get(0));
 123
 124         var createdAutomationComposition = automationCompositionProvider
 125             .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 126
 127         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(0), createdAutomationComposition);
 128
 129         when(automationCompositionRepository.save(any())).thenThrow(IllegalArgumentException.class);
 130
 131         assertThatThrownBy(() -> {
 132             automationCompositionProvider
 133                 .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 134         }).hasMessageMatching("Error in save automationComposition");
 135     }
 136
 137     @Test
 138     void testGetAutomationCompositions() throws Exception {
 139         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 140         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 141             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 142
 143         // Return empty list when no data present in db
 144         List<AutomationComposition> getResponse = automationCompositionProvider.getAutomationCompositions();
 145         assertThat(getResponse).isEmpty();
 146
 147         automationCompositionProvider
 148             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList());
 149
 150         var automationComposition0 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 151         var name = automationComposition0.getName();
 152         var version = automationComposition0.getVersion();
 153         var automationComposition1 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 154
 155         when(automationCompositionRepository.getFiltered(eq(JpaAutomationComposition.class), any(), any()))
 156             .thenReturn(List.of(new JpaAutomationComposition(automationComposition0),
 157                 new JpaAutomationComposition(automationComposition1)));
 158         when(automationCompositionRepository.findById(automationComposition0.getKey().asIdentifier().asConceptKey()))
 159             .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition0)));
 160         when(automationCompositionRepository.getById(automationComposition0.getKey().asIdentifier().asConceptKey()))
 161             .thenReturn(new JpaAutomationComposition(automationComposition0));
 162         when(automationCompositionRepository.getFiltered(JpaAutomationComposition.class, name, version))
 163             .thenReturn(List.of(new JpaAutomationComposition(automationComposition0)));
 164         when(automationCompositionRepository.findById(automationComposition1.getKey().asIdentifier().asConceptKey()))
 165             .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition1)));
 166
 167         assertEquals(1, automationCompositionProvider.getAutomationCompositions(name, version).size());
 168
 169         var ac = automationCompositionProvider
 170             .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION)).get();
 171         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 172
 173         ac = automationCompositionProvider.getAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION));
 174         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 175
 176         when(automationCompositionRepository.getById(any())).thenThrow(EntityNotFoundException.class);
 177
 178         assertThatThrownBy(() -> {
 179             automationCompositionProvider
 180                 .getAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION));
 181         }).hasMessageMatching("AutomationComposition not found");
 182
 183         ac = automationCompositionProvider.findAutomationComposition(ID_NAME, ID_VERSION).get();
 184         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 185
 186         assertThat(automationCompositionProvider
 187             .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION))).isEmpty();
 188
 189         when(automationCompositionRepository.findById(any())).thenThrow(IllegalArgumentException.class);
 190
 191         assertThatThrownBy(() -> {
 192             automationCompositionProvider.findAutomationComposition(ID_NAME_NOT_VALID, ID_VERSION);
 193         }).hasMessageMatching("Not valid parameter");
 194     }
 195
 196     @Test
 197     void testDeleteAutomationComposition() throws Exception {
 198         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 199         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 200             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 201
 202         assertThatThrownBy(() -> {
 203             automationCompositionProvider.deleteAutomationComposition(ID_NAME_NOT_EXTST, ID_VERSION);
 204         }).hasMessageMatching(".*.failed, automation composition does not exist");
 205
 206         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 207         var name = automationComposition.getName();
 208         var version = automationComposition.getVersion();
 209
 210         when(automationCompositionRepository.findById(new PfConceptKey(name, version)))
 211             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 212
 213         AutomationComposition deletedAc = automationCompositionProvider.deleteAutomationComposition(name, version);
 214         assertEquals(automationComposition, deletedAc);
 215     }
 216
 217     @Test
 218     void testDeleteAllInstanceProperties() throws Exception {
 219         var automationCompositionProvider =
 220             new AutomationCompositionProvider(mock(AutomationCompositionRepository.class),
 221                 mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 222         var toscaServiceTemplate = testAutomationCompositionRead();
 223         automationCompositionProvider.deleteInstanceProperties(
 224             automationCompositionProvider.saveInstanceProperties(toscaServiceTemplate),
 225             automationCompositionProvider.getAllNodeTemplates());
 226         assertThat(automationCompositionProvider.getAutomationCompositions()).isEmpty();
 227     }
 228
 229     @Test
 230     void testSaveAndDeleteInstanceProperties() throws Exception {
 231         var toscaNodeTemplatesRepository = mock(ToscaNodeTemplatesRepository.class);
 232         var toscaNodeTemplateRepository = mock(ToscaNodeTemplateRepository.class);
 233         var automationCompositionProvider = new AutomationCompositionProvider(
 234             mock(AutomationCompositionRepository.class), toscaNodeTemplateRepository, toscaNodeTemplatesRepository);
 235         var toscaServiceTest = testAutomationCompositionRead();
 236
 237         automationCompositionProvider.saveInstanceProperties(toscaServiceTest);
 238         verify(toscaNodeTemplatesRepository).save(any());
 239
 240         var name = "org.onap.policy.acm.PolicyAutomationCompositionParticipant";
 241         var version = "2.3.1";
 242         var elem = toscaServiceTest.getToscaTopologyTemplate().getNodeTemplates().get(name);
 243         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, name, version))
 244             .thenReturn(List.of(new JpaToscaNodeTemplate(elem)));
 245
 246         var filtered = automationCompositionProvider.getNodeTemplates(name, version);
 247         verify(toscaNodeTemplateRepository).getFiltered(JpaToscaNodeTemplate.class, name, version);
 248
 249         automationCompositionProvider
 250             .deleteInstanceProperties(automationCompositionProvider.saveInstanceProperties(toscaServiceTest), filtered);
 251
 252         verify(toscaNodeTemplateRepository).delete(any());
 253     }
 254
 255     @Test
 256     void testGetNodeTemplates() throws Exception {
 257         var toscaNodeTemplateRepository = mock(ToscaNodeTemplateRepository.class);
 258         var automationCompositionProvider =
 259             new AutomationCompositionProvider(mock(AutomationCompositionRepository.class), toscaNodeTemplateRepository,
 260                 mock(ToscaNodeTemplatesRepository.class));
 261
 262         var toscaNodeTemplate0 = new JpaToscaNodeTemplate(new PfConceptKey(ID_NAME, ID_VERSION));
 263         var toscaNodeTemplate1 = new JpaToscaNodeTemplate(new PfConceptKey("PMSHInstance2", ID_VERSION));
 264
 265         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, null, null))
 266             .thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
 267         when(toscaNodeTemplateRepository.findAll()).thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
 268         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, ID_NAME, ID_VERSION))
 269             .thenReturn(List.of(toscaNodeTemplate0));
 270
 271         // Getting all nodes
 272         var listNodes = automationCompositionProvider.getAllNodeTemplates();
 273         assertNotNull(listNodes);
 274         assertThat(listNodes).hasSize(2);
 275
 276         listNodes = automationCompositionProvider.getNodeTemplates(ID_NAME, ID_VERSION);
 277         assertNotNull(listNodes);
 278         assertThat(listNodes).hasSize(1);
 279
 280         listNodes = automationCompositionProvider.getAllNodeTemplates();
 281         assertNotNull(listNodes);
 282         assertThat(listNodes).hasSize(2);
 283
 284         var nodeTemplateFilter =
 285             ToscaTypedEntityFilter.<ToscaNodeTemplate>builder().name(ID_NAME).version(ID_VERSION).build();
 286
 287         listNodes = automationCompositionProvider.getFilteredNodeTemplates(nodeTemplateFilter);
 288         assertNotNull(listNodes);
 289         assertThat(listNodes).hasSize(1);
 290
 291         assertThatThrownBy(() -> {
 292             automationCompositionProvider.getFilteredNodeTemplates(null);
 293         }).hasMessageMatching("filter is marked non-null but is null");
 294     }
 295
 296     private static ToscaServiceTemplate testAutomationCompositionRead() {
 297         return testAutomationCompositionYamlSerialization(TOSCA_TEMPLATE_YAML);
 298     }
 299
 300     private static ToscaServiceTemplate testAutomationCompositionYamlSerialization(
 301         String automationCompositionFilePath) {
 302         var automationCompositionString = ResourceUtils.getResourceAsString(automationCompositionFilePath);
 303         return yamlTranslator.fromYaml(automationCompositionString, ToscaServiceTemplate.class);
 304     }
 305 }