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.when;
  31
  32 import java.util.List;
  33 import java.util.Optional;
  34 import javax.persistence.EntityNotFoundException;
  35 import org.junit.jupiter.api.BeforeEach;
  36 import org.junit.jupiter.api.Test;
  37 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  38 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  39 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationComposition;
  40 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
  41 import org.onap.policy.clamp.models.acm.persistence.repository.ToscaNodeTemplateRepository;
  42 import org.onap.policy.common.utils.coder.Coder;
  43 import org.onap.policy.common.utils.coder.StandardCoder;
  44 import org.onap.policy.common.utils.resources.ResourceUtils;
  45 import org.onap.policy.models.base.PfConceptKey;
  46 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  47 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaTypedEntityFilter;
  49 import org.onap.policy.models.tosca.simple.concepts.JpaToscaNodeTemplate;
  50
  51 class AutomationCompositionProviderTest {
  52
  53     private static final String LIST_IS_NULL = "automationCompositions is marked .*ull but is null";
  54     private static final String OBJECT_IS_NULL = "automationComposition is marked non-null but is null";
  55
  56     private static final String ID_NAME = "PMSHInstance1";
  57     private static final String ID_VERSION = "1.0.1";
  58     private static final String ID_NAME_NOT_EXTST = "not_exist";
  59     private static final String ID_NAME_NOT_VALID = "not_valid";
  60
  61     private static final Coder CODER = new StandardCoder();
  62     private static final String AUTOMATION_COMPOSITION_JSON =
  63         "src/test/resources/providers/TestAutomationCompositions.json";
  64
  65     private AutomationCompositions inputAutomationCompositions;
  66     private List<JpaAutomationComposition> inputAutomationCompositionsJpa;
  67     private final String originalJson = ResourceUtils.getResourceAsString(AUTOMATION_COMPOSITION_JSON);
  68
  69     @BeforeEach
  70     void beforeSetupDao() throws Exception {
  71         inputAutomationCompositions = CODER.decode(originalJson, AutomationCompositions.class);
  72         inputAutomationCompositionsJpa =
  73             ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
  74                 JpaAutomationComposition::new, "automation compositions");
  75     }
  76
  77     @Test
  78     void testAutomationCompositionsSave() throws Exception {
  79         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
  80         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
  81             mock(ToscaNodeTemplateRepository.class));
  82
  83         assertThatThrownBy(() -> automationCompositionProvider.saveAutomationCompositions(null))
  84             .hasMessageMatching(LIST_IS_NULL);
  85
  86         when(automationCompositionRepository.saveAll(inputAutomationCompositionsJpa))
  87             .thenReturn(inputAutomationCompositionsJpa);
  88
  89         var createdAutomationCompositions = new AutomationCompositions();
  90         createdAutomationCompositions.setAutomationCompositionList(automationCompositionProvider
  91             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()));
  92
  93         assertEquals(inputAutomationCompositions, createdAutomationCompositions);
  94
  95         when(automationCompositionRepository.saveAll(any())).thenThrow(IllegalArgumentException.class);
  96
  97         assertThatThrownBy(() -> automationCompositionProvider
  98             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList()))
  99             .hasMessageMatching("Error in save AutomationCompositions");
 100     }
 101
 102     @Test
 103     void testAutomationCompositionSave() throws Exception {
 104         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 105         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 106             mock(ToscaNodeTemplateRepository.class));
 107
 108         assertThatThrownBy(() -> automationCompositionProvider.saveAutomationComposition(null))
 109             .hasMessageMatching(OBJECT_IS_NULL);
 110
 111         when(automationCompositionRepository.save(inputAutomationCompositionsJpa.get(0)))
 112             .thenReturn(inputAutomationCompositionsJpa.get(0));
 113
 114         var createdAutomationComposition = automationCompositionProvider
 115             .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 116
 117         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(0), createdAutomationComposition);
 118
 119         when(automationCompositionRepository.save(any())).thenThrow(IllegalArgumentException.class);
 120
 121         assertThatThrownBy(() -> automationCompositionProvider
 122             .saveAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0)))
 123             .hasMessageMatching("Error in save automationComposition");
 124     }
 125
 126     @Test
 127     void testGetAutomationCompositions() throws Exception {
 128         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 129         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 130             mock(ToscaNodeTemplateRepository.class));
 131
 132         // Return empty list when no data present in db
 133         List<AutomationComposition> getResponse = automationCompositionProvider.getAutomationCompositions();
 134         assertThat(getResponse).isEmpty();
 135
 136         automationCompositionProvider
 137             .saveAutomationCompositions(inputAutomationCompositions.getAutomationCompositionList());
 138
 139         var automationComposition0 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 140         var name = automationComposition0.getName();
 141         var version = automationComposition0.getVersion();
 142         var automationComposition1 = inputAutomationCompositions.getAutomationCompositionList().get(1);
 143
 144         when(automationCompositionRepository.getFiltered(eq(JpaAutomationComposition.class), any(), any()))
 145             .thenReturn(List.of(new JpaAutomationComposition(automationComposition0),
 146                 new JpaAutomationComposition(automationComposition1)));
 147         when(automationCompositionRepository.findById(automationComposition0.getKey().asIdentifier().asConceptKey()))
 148             .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition0)));
 149         when(automationCompositionRepository.getById(automationComposition0.getKey().asIdentifier().asConceptKey()))
 150             .thenReturn(new JpaAutomationComposition(automationComposition0));
 151         when(automationCompositionRepository.getFiltered(JpaAutomationComposition.class, name, version))
 152             .thenReturn(List.of(new JpaAutomationComposition(automationComposition0)));
 153         when(automationCompositionRepository.findById(automationComposition1.getKey().asIdentifier().asConceptKey()))
 154             .thenReturn(Optional.of(new JpaAutomationComposition(automationComposition1)));
 155
 156         assertEquals(1, automationCompositionProvider.getAutomationCompositions(name, version).size());
 157
 158         var ac = automationCompositionProvider
 159             .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION))
 160             .orElse(new AutomationComposition());
 161         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 162
 163         ac = automationCompositionProvider.getAutomationComposition(new ToscaConceptIdentifier(ID_NAME, ID_VERSION));
 164         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 165
 166         when(automationCompositionRepository.getById(any())).thenThrow(EntityNotFoundException.class);
 167
 168         assertThatThrownBy(() -> automationCompositionProvider
 169             .getAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION)))
 170             .hasMessageMatching("AutomationComposition not found");
 171
 172         ac = automationCompositionProvider.findAutomationComposition(ID_NAME, ID_VERSION)
 173             .orElse(new AutomationComposition());
 174         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(1), ac);
 175
 176         assertThat(automationCompositionProvider
 177             .findAutomationComposition(new ToscaConceptIdentifier(ID_NAME_NOT_EXTST, ID_VERSION))).isEmpty();
 178
 179         when(automationCompositionRepository.findById(any())).thenThrow(IllegalArgumentException.class);
 180
 181         assertThatThrownBy(() -> automationCompositionProvider.findAutomationComposition(ID_NAME_NOT_VALID, ID_VERSION))
 182             .hasMessageMatching("Not valid parameter");
 183     }
 184
 185     @Test
 186     void testDeleteAutomationComposition() throws Exception {
 187         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 188         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 189             mock(ToscaNodeTemplateRepository.class));
 190
 191         assertThatThrownBy(() -> automationCompositionProvider
 192             .deleteAutomationComposition(ID_NAME_NOT_EXTST, ID_VERSION))
 193             .hasMessageMatching(".*.failed, automation composition does not exist");
 194
 195         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 196         var name = automationComposition.getName();
 197         var version = automationComposition.getVersion();
 198
 199         when(automationCompositionRepository.findById(new PfConceptKey(name, version)))
 200             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 201
 202         AutomationComposition deletedAc = automationCompositionProvider.deleteAutomationComposition(name, version);
 203         assertEquals(automationComposition, deletedAc);
 204     }
 205
 206     @Test
 207     void testGetNodeTemplates() {
 208         var toscaNodeTemplateRepository = mock(ToscaNodeTemplateRepository.class);
 209         var automationCompositionProvider =
 210             new AutomationCompositionProvider(mock(AutomationCompositionRepository.class), toscaNodeTemplateRepository);
 211
 212         var toscaNodeTemplate0 = new JpaToscaNodeTemplate(new PfConceptKey(ID_NAME, ID_VERSION));
 213         var toscaNodeTemplate1 = new JpaToscaNodeTemplate(new PfConceptKey("PMSHInstance2", ID_VERSION));
 214
 215         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, null, null))
 216             .thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
 217         when(toscaNodeTemplateRepository.findAll()).thenReturn(List.of(toscaNodeTemplate0, toscaNodeTemplate1));
 218         when(toscaNodeTemplateRepository.getFiltered(JpaToscaNodeTemplate.class, ID_NAME, ID_VERSION))
 219             .thenReturn(List.of(toscaNodeTemplate0));
 220
 221         // Getting all nodes
 222         var listNodes = automationCompositionProvider.getAllNodeTemplates();
 223         assertNotNull(listNodes);
 224         assertThat(listNodes).hasSize(2);
 225
 226         listNodes = automationCompositionProvider.getNodeTemplates(ID_NAME, ID_VERSION);
 227         assertNotNull(listNodes);
 228         assertThat(listNodes).hasSize(1);
 229
 230         listNodes = automationCompositionProvider.getAllNodeTemplates();
 231         assertNotNull(listNodes);
 232         assertThat(listNodes).hasSize(2);
 233
 234         var nodeTemplateFilter =
 235             ToscaTypedEntityFilter.<ToscaNodeTemplate>builder().name(ID_NAME).version(ID_VERSION).build();
 236
 237         listNodes = automationCompositionProvider.getFilteredNodeTemplates(nodeTemplateFilter);
 238         assertNotNull(listNodes);
 239         assertThat(listNodes).hasSize(1);
 240
 241         assertThatThrownBy(() -> automationCompositionProvider.getFilteredNodeTemplates(null))
 242             .hasMessageMatching("filter is marked non-null but is null");
 243     }
 244 }