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.junit.jupiter.api.Assertions.assertDoesNotThrow;
  26 import static org.junit.jupiter.api.Assertions.assertEquals;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.anyIterable;
  29 import static org.mockito.ArgumentMatchers.anyList;
  30 import static org.mockito.Mockito.mock;
  31 import static org.mockito.Mockito.verify;
  32 import static org.mockito.Mockito.when;
  33
  34 import java.util.ArrayList;
  35 import java.util.List;
  36 import java.util.Optional;
  37 import java.util.UUID;
  38 import org.junit.jupiter.api.BeforeEach;
  39 import org.junit.jupiter.api.Test;
  40 import org.mockito.Mockito;
  41 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementInfo;
  42 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionInfo;
  43 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  44 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  45 import org.onap.policy.clamp.models.acm.concepts.LockState;
  46 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationComposition;
  47 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationCompositionElement;
  48 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionElementRepository;
  49 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
  50 import org.onap.policy.common.utils.coder.Coder;
  51 import org.onap.policy.common.utils.coder.StandardCoder;
  52 import org.onap.policy.common.utils.resources.ResourceUtils;
  53 import org.springframework.data.domain.Example;
  54
  55 class AutomationCompositionProviderTest {
  56
  57     private static final String AC_IS_NULL = "automationComposition is marked non-null but is null";
  58     private static final String ACELEMENT_IS_NULL = "element is marked non-null but is null";
  59
  60     private static final Coder CODER = new StandardCoder();
  61     private static final String AUTOMATION_COMPOSITION_JSON =
  62             "src/test/resources/providers/TestAutomationCompositions.json";
  63
  64     private AutomationCompositions inputAutomationCompositions;
  65     private List<JpaAutomationComposition> inputAutomationCompositionsJpa;
  66     private final String originalJson = ResourceUtils.getResourceAsString(AUTOMATION_COMPOSITION_JSON);
  67
  68     @BeforeEach
  69     void beforeSetupDao() throws Exception {
  70         inputAutomationCompositions = CODER.decode(originalJson, AutomationCompositions.class);
  71         inputAutomationCompositionsJpa =
  72                 ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
  73                         JpaAutomationComposition::new, "automation compositions");
  74     }
  75
  76     @Test
  77     void testAutomationCompositionCreate() {
  78         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
  79         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
  80                 mock(AutomationCompositionElementRepository.class));
  81
  82         when(automationCompositionRepository.save(any(JpaAutomationComposition.class)))
  83                 .thenReturn(inputAutomationCompositionsJpa.get(0));
  84         var inputAc = inputAutomationCompositions.getAutomationCompositionList().get(0);
  85
  86         var createdAutomationComposition = automationCompositionProvider.createAutomationComposition(inputAc);
  87         inputAc.setInstanceId(createdAutomationComposition.getInstanceId());
  88         assertEquals(inputAc, createdAutomationComposition);
  89     }
  90
  91     @Test
  92     void testAutomationCompositionUpdate() {
  93         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
  94         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
  95                 mock(AutomationCompositionElementRepository.class));
  96
  97         assertThatThrownBy(() -> automationCompositionProvider.updateAutomationComposition(null))
  98                 .hasMessageMatching(AC_IS_NULL);
  99
 100         when(automationCompositionRepository.save(inputAutomationCompositionsJpa.get(0)))
 101                 .thenReturn(inputAutomationCompositionsJpa.get(0));
 102
 103         var createdAutomationComposition = automationCompositionProvider
 104                 .updateAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 105
 106         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(0), createdAutomationComposition);
 107     }
 108
 109     @Test
 110     void testGetAutomationCompositions() {
 111         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 112         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 113                 mock(AutomationCompositionElementRepository.class));
 114
 115         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 116         var acList = automationCompositionProvider.getAutomationCompositions(UUID.randomUUID(),
 117                 automationComposition.getName(), automationComposition.getVersion());
 118         assertThat(acList).isEmpty();
 119
 120         when(automationCompositionRepository.findAll(Mockito.<Example<JpaAutomationComposition>>any()))
 121                 .thenReturn(inputAutomationCompositionsJpa);
 122         acList = automationCompositionProvider.getAutomationCompositions(automationComposition.getCompositionId(), null,
 123                 null);
 124         assertThat(acList).hasSize(2);
 125     }
 126
 127     @Test
 128     void testGetAutomationComposition() {
 129         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 130         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 131                 mock(AutomationCompositionElementRepository.class));
 132
 133         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 134         assertThatThrownBy(
 135                 () -> automationCompositionProvider.getAutomationComposition(automationComposition.getInstanceId()))
 136                         .hasMessageMatching("AutomationComposition not found");
 137
 138         when(automationCompositionRepository.findById(automationComposition.getInstanceId().toString()))
 139                 .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 140         var ac = automationCompositionProvider.getAutomationComposition(automationComposition.getInstanceId());
 141         assertEquals(automationComposition, ac);
 142     }
 143
 144     @Test
 145     void testFindAutomationComposition() {
 146         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 147         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 148                 mock(AutomationCompositionElementRepository.class));
 149
 150         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 151         var acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getInstanceId());
 152         assertThat(acOpt).isEmpty();
 153
 154         acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getKey().asIdentifier());
 155         assertThat(acOpt).isEmpty();
 156
 157         when(automationCompositionRepository.findById(automationComposition.getInstanceId().toString()))
 158                 .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 159         acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getInstanceId());
 160         assertEquals(automationComposition, acOpt.get());
 161
 162         when(automationCompositionRepository.findOne(Mockito.<Example<JpaAutomationComposition>>any()))
 163                 .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 164         acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getKey().asIdentifier());
 165         assertEquals(automationComposition, acOpt.get());
 166     }
 167
 168     @Test
 169     void testGetAcInstancesByCompositionId() {
 170         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 171         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 172                 mock(AutomationCompositionElementRepository.class));
 173
 174         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 175         when(automationCompositionRepository.findByCompositionId(automationComposition.getCompositionId().toString()))
 176                 .thenReturn(inputAutomationCompositionsJpa);
 177         var acList =
 178                 automationCompositionProvider.getAcInstancesByCompositionId(automationComposition.getCompositionId());
 179         assertEquals(inputAutomationCompositions.getAutomationCompositionList(), acList);
 180     }
 181
 182     @Test
 183     void testGetAcInstancesInTransition() {
 184         inputAutomationCompositions.getAutomationCompositionList().get(0).setDeployState(DeployState.DEPLOYING);
 185         inputAutomationCompositions.getAutomationCompositionList().get(1).setLockState(LockState.LOCKING);
 186         inputAutomationCompositionsJpa.get(0).setDeployState(DeployState.DEPLOYING);
 187         inputAutomationCompositionsJpa.get(1).setLockState(LockState.LOCKING);
 188
 189         List<JpaAutomationComposition> res1 = new ArrayList<>();
 190         res1.add(inputAutomationCompositionsJpa.get(0));
 191         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 192         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 193             mock(AutomationCompositionElementRepository.class));
 194         when(automationCompositionRepository.findByDeployStateIn(List.of(DeployState.DEPLOYING,
 195             DeployState.UNDEPLOYING, DeployState.DELETING, DeployState.UPDATING, DeployState.MIGRATING)))
 196             .thenReturn(res1);
 197         when(automationCompositionRepository.findByLockStateIn(List.of(LockState.LOCKING, LockState.UNLOCKING)))
 198             .thenReturn(List.of(inputAutomationCompositionsJpa.get(1)));
 199         var acList = automationCompositionProvider.getAcInstancesInTransition();
 200         assertEquals(inputAutomationCompositions.getAutomationCompositionList(), acList);
 201     }
 202
 203     @Test
 204     void testDeleteAutomationComposition() {
 205         var automationCompositionRepository = mock(AutomationCompositionRepository.class);
 206         var automationCompositionProvider = new AutomationCompositionProvider(automationCompositionRepository,
 207                 mock(AutomationCompositionElementRepository.class));
 208
 209         assertThatThrownBy(() -> automationCompositionProvider.deleteAutomationComposition(UUID.randomUUID()))
 210                 .hasMessageMatching(".*.failed, automation composition does not exist");
 211
 212         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 213         when(automationCompositionRepository.findById(automationComposition.getInstanceId().toString()))
 214                 .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 215
 216         var deletedAc =
 217                 automationCompositionProvider.deleteAutomationComposition(automationComposition.getInstanceId());
 218         assertEquals(automationComposition, deletedAc);
 219     }
 220
 221     @Test
 222     void testAutomationCompositionElementUpdate() {
 223         var acElementRepository = mock(AutomationCompositionElementRepository.class);
 224         var automationCompositionProvider = new AutomationCompositionProvider(
 225             mock(AutomationCompositionRepository.class), acElementRepository);
 226
 227         assertThatThrownBy(() -> automationCompositionProvider.updateAutomationCompositionElement(null, null))
 228             .hasMessageMatching(ACELEMENT_IS_NULL);
 229
 230         var acElement = inputAutomationCompositions.getAutomationCompositionList().get(0).getElements().values()
 231             .iterator().next();
 232         automationCompositionProvider.updateAutomationCompositionElement(acElement, UUID.randomUUID());
 233         verify(acElementRepository).save(any());
 234     }
 235
 236     @Test
 237     void testValidateElementIds() {
 238         var acElementRepository = mock(AutomationCompositionElementRepository.class);
 239         var automationCompositionProvider = new AutomationCompositionProvider(
 240             mock(AutomationCompositionRepository.class), acElementRepository);
 241
 242         var ac = inputAutomationCompositions.getAutomationCompositionList().get(0);
 243
 244         var result = automationCompositionProvider.validateElementIds(ac);
 245         assertThat(result.isValid()).isTrue();
 246
 247         var jpaElement = new JpaAutomationCompositionElement(ac.getElements().values().iterator().next());
 248         when(acElementRepository.findAllById(anyIterable()))
 249             .thenReturn(List.of(jpaElement));
 250
 251         ac.setInstanceId(null);
 252         result = automationCompositionProvider.validateElementIds(ac);
 253         assertThat(result.isValid()).isFalse();
 254
 255         ac.setInstanceId(UUID.randomUUID());
 256         jpaElement.setInstanceId(UUID.randomUUID().toString());
 257         result = automationCompositionProvider.validateElementIds(ac);
 258         assertThat(result.isValid()).isFalse();
 259
 260         ac.setInstanceId(UUID.randomUUID());
 261         jpaElement.setInstanceId(ac.getInstanceId().toString());
 262         result = automationCompositionProvider.validateElementIds(ac);
 263         assertThat(result.isValid()).isTrue();
 264     }
 265
 266     @Test
 267     void testUpgradeStates() {
 268         var acElementRepository = mock(AutomationCompositionElementRepository.class);
 269         var automationCompositionProvider = new AutomationCompositionProvider(
 270             mock(AutomationCompositionRepository.class), acElementRepository);
 271
 272         assertDoesNotThrow(() -> automationCompositionProvider.upgradeStates(List.of()));
 273         var acElement = inputAutomationCompositions.getAutomationCompositionList().get(0).getElements().values()
 274             .iterator().next();
 275
 276         var acInfo = new AutomationCompositionInfo();
 277         var acElementInfo = new AutomationCompositionElementInfo();
 278         acInfo.setElements(List.of(acElementInfo));
 279         acElementInfo.setAutomationCompositionElementId(acElement.getId());
 280
 281         when(acElementRepository.getReferenceById(acElement.getId().toString()))
 282             .thenReturn(new JpaAutomationCompositionElement(acElement));
 283
 284         automationCompositionProvider.upgradeStates(List.of(acInfo));
 285         verify(acElementRepository).saveAll(anyList());
 286     }
 287 }