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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2021-2022 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.jupiter.api.Assertions.assertEquals;
  26 import static org.junit.jupiter.api.Assertions.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/test-pm-subscription-handling.yaml";
  69
  70     private static final YamlJsonTranslator yamlTranslator = new YamlJsonTranslator();
  71
  72     private AutomationCompositions inputAutomationCompositions;
  73     private List<JpaAutomationComposition> inputAutomationCompositionsJpa;
  74     private final 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(() -> automationCompositionProvider.saveAutomationCompositions(null))
  91             .hasMessageMatching(LIST_IS_NULL);
  92
  93         when(automationCompositionRepository.saveAll(inputAutomationCompositionsJpa))
  94             .thenReturn(inputAutomationCompositionsJpa);
  95
  96         var createdAutomationCompositions = new AutomationCompositions();
  97         createdAutomationCompositions.setAutomationCompositionList(automationCompositionProvider
  98             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()));
  99
 100         assertEquals(inputAutomationCompositions, createdAutomationCompositions);
 101
 102         when(automationCompositionRepository.saveAll(any())).thenThrow(IllegalArgumentException.class);
 103
 104         assertThatThrownBy(() -> automationCompositionProvider
 105             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()))
 106             .hasMessageMatching("Error in save AutomationCompositions");
 107     }
 108
 109     @Test
 110     void testAutomationCompositionSave() throws Exception {
 111         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 112         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 113             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 114
 115         assertThatThrownBy(() -> automationCompositionProvider.saveAutomationComposition(null))
 116             .hasMessageMatching(OBJECT_IS_NULL);
 117
 118         when(automationCompositionRepository.save(inputAutomationCompositionsJpa.get(0)))
 119             .thenReturn(inputAutomationCompositionsJpa.get(0));
 120
 121         var createdAutomationComposition = automationCompositionProvider
 122             .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 123
 124         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(0), createdAutomationComposition);
 125
 126         when(automationCompositionRepository.save(any())).thenThrow(IllegalArgumentException.class);
 127
 128         assertThatThrownBy(() -> automationCompositionProvider
 129             .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0)))
 130             .hasMessageMatching("Error in save automationComposition");
 131     }
 132
 133     @Test
 134     void testGetAutomationCompositions() throws Exception {
 135         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 136         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 137             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 138
 139         // Return empty list when no data present in db
 140         List<AutomationComposition> getResponse = automationCompositionProvider.getAutomationCompositions();
 141         assertThat(getResponse).isEmpty();
 142
 143         automationCompositionProvider
 144             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList());
 145
 146         var automationComposition0 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 147         var name = automationComposition0.getName();
 148         var version = automationComposition0.getVersion();
 149         var automationComposition1 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 150
 151         when(automationCompositionRepository.getFiltered(eq(JpaAutomationComposition.class), any(), any()))
 152             .thenReturn(List.of(new JpaAutomationComposition(automationComposition0),
 153                 new JpaAutomationComposition(automationComposition1)));
 154         when(automationCompositionRepository.findById(automationComposition0.getKey().asIdentifier().asConceptKey()))
 155             .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition0)));
 156         when(automationCompositionRepository.getById(automationComposition0.getKey().asIdentifier().asConceptKey()))
 157             .thenReturn(new JpaAutomationComposition(automationComposition0));
 158         when(automationCompositionRepository.getFiltered(JpaAutomationComposition.class, name, version))
 159             .thenReturn(List.of(new JpaAutomationComposition(automationComposition0)));
 160         when(automationCompositionRepository.findById(automationComposition1.getKey().asIdentifier().asConceptKey()))
 161             .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition1)));
 162
 163         assertEquals(1, automationCompositionProvider.getAutomationCompositions(name, version).size());
 164
 165         var ac = automationCompositionProvider
 166             .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION))
 167             .orElse(new AutomationComposition());
 168         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 169
 170         ac = automationCompositionProvider.getAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION));
 171         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 172
 173         when(automationCompositionRepository.getById(any())).thenThrow(EntityNotFoundException.class);
 174
 175         assertThatThrownBy(() -> automationCompositionProvider
 176             .getAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION)))
 177             .hasMessageMatching("AutomationComposition not found");
 178
 179         ac = automationCompositionProvider.findAutomationComposition(ID_NAME, ID_VERSION)
 180             .orElse(new AutomationComposition());
 181         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 182
 183         assertThat(automationCompositionProvider
 184             .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION))).isEmpty();
 185
 186         when(automationCompositionRepository.findById(any())).thenThrow(IllegalArgumentException.class);
 187
 188         assertThatThrownBy(() -> automationCompositionProvider.findAutomationComposition(ID_NAME_NOT_VALID, ID_VERSION))
 189             .hasMessageMatching("Not valid parameter");
 190     }
 191
 192     @Test
 193     void testDeleteAutomationComposition() throws Exception {
 194         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 195         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 196             mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 197
 198         assertThatThrownBy(() -> automationCompositionProvider
 199             .deleteAutomationComposition(ID_NAME_NOT_EXTST, ID_VERSION))
 200             .hasMessageMatching(".*.failed, automation composition does not exist");
 201
 202         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 203         var name = automationComposition.getName();
 204         var version = automationComposition.getVersion();
 205
 206         when(automationCompositionRepository.findById(new PfConceptKey(name, version)))
 207             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 208
 209         AutomationComposition deletedAc = automationCompositionProvider.deleteAutomationComposition(name, version);
 210         assertEquals(automationComposition, deletedAc);
 211     }
 212
 213     @Test
 214     void testDeleteAllInstanceProperties() throws Exception {
 215         var automationCompositionProvider =
 216             new AutomationCompositionProvider(mock(AutomationCompositionRepository.class),
 217                 mock(ToscaNodeTemplateRepository.class), mock(ToscaNodeTemplatesRepository.class));
 218         var toscaServiceTemplate = testAutomationCompositionRead();
 219         automationCompositionProvider.deleteInstanceProperties(
 220             automationCompositionProvider.saveInstanceProperties(toscaServiceTemplate),
 221             automationCompositionProvider.getAllNodeTemplates());
 222         assertThat(automationCompositionProvider.getAutomationCompositions()).isEmpty();
 223     }
 224
 225     @Test
 226     void testSaveAndDeleteInstanceProperties() {
 227         var toscaNodeTemplatesRepository = mock(ToscaNodeTemplatesRepository.class);
 228         var toscaNodeTemplateRepository = mock(ToscaNodeTemplateRepository.class);
 229         var automationCompositionProvider = new AutomationCompositionProvider(
 230             mock(AutomationCompositionRepository.class), toscaNodeTemplateRepository, toscaNodeTemplatesRepository);
 231         var toscaServiceTest = testAutomationCompositionRead();
 232
 233         automationCompositionProvider.saveInstanceProperties(toscaServiceTest);
 234         verify(toscaNodeTemplatesRepository).save(any());
 235
 236         var name = "org.onap.policy.acm.PolicyAutomationCompositionParticipant";
 237         var version = "2.3.1";
 238         var elem = toscaServiceTest.getToscaTopologyTemplate().getNodeTemplates().get(name);
 239         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, name, version))
 240             .thenReturn(List.of(new JpaToscaNodeTemplate(elem)));
 241
 242         var filtered = automationCompositionProvider.getNodeTemplates(name, version);
 243         verify(toscaNodeTemplateRepository).getFiltered(JpaToscaNodeTemplate.class, name, version);
 244
 245         automationCompositionProvider
 246             .deleteInstanceProperties(automationCompositionProvider.saveInstanceProperties(toscaServiceTest), filtered);
 247
 248         verify(toscaNodeTemplateRepository).delete(any());
 249     }
 250
 251     @Test
 252     void testGetNodeTemplates() {
 253         var toscaNodeTemplateRepository = mock(ToscaNodeTemplateRepository.class);
 254         var automationCompositionProvider =
 255             new AutomationCompositionProvider(mock(AutomationCompositionRepository.class), toscaNodeTemplateRepository,
 256                 mock(ToscaNodeTemplatesRepository.class));
 257
 258         var toscaNodeTemplate0 = new JpaToscaNodeTemplate(new PfConceptKey(ID_NAME, ID_VERSION));
 259         var toscaNodeTemplate1 = new JpaToscaNodeTemplate(new PfConceptKey("PMSHInstance2", ID_VERSION));
 260
 261         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, null, null))
 262             .thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
 263         when(toscaNodeTemplateRepository.findAll()).thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
 264         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, ID_NAME, ID_VERSION))
 265             .thenReturn(List.of(toscaNodeTemplate0));
 266
 267         // Getting all nodes
 268         var listNodes = automationCompositionProvider.getAllNodeTemplates();
 269         assertNotNull(listNodes);
 270         assertThat(listNodes).hasSize(2);
 271
 272         listNodes = automationCompositionProvider.getNodeTemplates(ID_NAME, ID_VERSION);
 273         assertNotNull(listNodes);
 274         assertThat(listNodes).hasSize(1);
 275
 276         listNodes = automationCompositionProvider.getAllNodeTemplates();
 277         assertNotNull(listNodes);
 278         assertThat(listNodes).hasSize(2);
 279
 280         var nodeTemplateFilter =
 281             ToscaTypedEntityFilter.<ToscaNodeTemplate>builder().name(ID_NAME).version(ID_VERSION).build();
 282
 283         listNodes = automationCompositionProvider.getFilteredNodeTemplates(nodeTemplateFilter);
 284         assertNotNull(listNodes);
 285         assertThat(listNodes).hasSize(1);
 286
 287         assertThatThrownBy(() -> automationCompositionProvider.getFilteredNodeTemplates(null))
 288             .hasMessageMatching("filter is marked non-null but is null");
 289     }
 290
 291     private static ToscaServiceTemplate testAutomationCompositionRead() {
 292         return testAutomationCompositionYamlSerialization();
 293     }
 294
 295     private static ToscaServiceTemplate testAutomationCompositionYamlSerialization() {
 296         var automationCompositionString = ResourceUtils.getResourceAsString(
 297             AutomationCompositionProviderTest.TOSCA_TEMPLATE_YAML);
 298         return yamlTranslator.fromYaml(automationCompositionString, ToscaServiceTemplate.class);
 299     }
 300 }