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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
   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.mockito.ArgumentMatchers.any;
  27 import static org.mockito.ArgumentMatchers.anyIterable;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31
  32 import java.util.ArrayList;
  33 import java.util.List;
  34 import java.util.Optional;
  35 import java.util.UUID;
  36 import org.junit.jupiter.api.BeforeEach;
  37 import org.junit.jupiter.api.Test;
  38 import org.mockito.Mockito;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  40 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  41 import org.onap.policy.clamp.models.acm.concepts.LockState;
  42 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationComposition;
  43 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationCompositionElement;
  44 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationCompositionRollback;
  45 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionElementRepository;
  46 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRepository;
  47 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionRollbackRepository;
  48 import org.onap.policy.common.utils.coder.Coder;
  49 import org.onap.policy.common.utils.coder.StandardCoder;
  50 import org.onap.policy.common.utils.resources.ResourceUtils;
  51 import org.springframework.data.domain.PageImpl;
  52 import org.springframework.data.domain.PageRequest;
  53 import org.springframework.data.domain.Pageable;
  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_ID_IS_NULL = "elementId 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     private AutomationCompositionProvider automationCompositionProvider;
  69     private AutomationCompositionRepository automationCompositionRepository;
  70     private AutomationCompositionElementRepository acElementRepository;
  71     private AutomationCompositionRollbackRepository acRollbackRepository;
  72
  73     @BeforeEach
  74     void beforeSetupDao() throws Exception {
  75         inputAutomationCompositions = CODER.decode(originalJson, AutomationCompositions.class);
  76         inputAutomationCompositionsJpa =
  77             ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
  78                 JpaAutomationComposition::new, "automation compositions");
  79
  80         // set mocks
  81         automationCompositionRepository = mock(AutomationCompositionRepository.class);
  82         acElementRepository = mock(AutomationCompositionElementRepository.class);
  83         acRollbackRepository = mock(AutomationCompositionRollbackRepository.class);
  84         automationCompositionProvider =
  85             new AutomationCompositionProvider(automationCompositionRepository, acElementRepository,
  86                 acRollbackRepository);
  87     }
  88
  89     @Test
  90     void testAutomationCompositionCreate() {
  91         when(automationCompositionRepository.save(any(JpaAutomationComposition.class)))
  92             .thenReturn(inputAutomationCompositionsJpa.get(0));
  93         var inputAc = inputAutomationCompositions.getAutomationCompositionList().get(0);
  94
  95         var createdAutomationComposition = automationCompositionProvider.createAutomationComposition(inputAc);
  96         inputAc.setInstanceId(createdAutomationComposition.getInstanceId());
  97         inputAc.setLastMsg(createdAutomationComposition.getLastMsg());
  98         assertEquals(inputAc, createdAutomationComposition);
  99     }
 100
 101     @Test
 102     void testAutomationCompositionUpdate() {
 103         assertThatThrownBy(() -> automationCompositionProvider.updateAutomationComposition(null))
 104             .hasMessageMatching(AC_IS_NULL);
 105
 106         when(automationCompositionRepository.save(inputAutomationCompositionsJpa.get(0)))
 107             .thenReturn(inputAutomationCompositionsJpa.get(0));
 108
 109         var createdAutomationComposition = automationCompositionProvider
 110             .updateAutomationComposition(inputAutomationCompositions.getAutomationCompositionList().get(0));
 111
 112         assertEquals(inputAutomationCompositions.getAutomationCompositionList().get(0), createdAutomationComposition);
 113     }
 114
 115     @Test
 116     void testGetAutomationCompositionsWithNull() {
 117         assertThatThrownBy(() -> automationCompositionProvider
 118             .getAutomationCompositions(UUID.randomUUID(), null, null, null))
 119             .hasMessage("pageable is marked non-null but is null");
 120
 121         assertThatThrownBy(() -> automationCompositionProvider
 122             .getAutomationCompositions(null, null, null, Pageable.unpaged()))
 123             .hasMessage("compositionId is marked non-null but is null");
 124     }
 125
 126     @Test
 127     void testGetAutomationCompositions() {
 128         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 129         when(automationCompositionRepository
 130             .findAll(Mockito.any(), any(Pageable.class)))
 131             .thenReturn(new PageImpl<>(inputAutomationCompositionsJpa));
 132         var acList = automationCompositionProvider.getAutomationCompositions(UUID.randomUUID(),
 133             automationComposition.getName(), automationComposition.getVersion(), Pageable.unpaged());
 134         assertThat(acList).hasSize(2);
 135
 136         acList = automationCompositionProvider.getAutomationCompositions(automationComposition.getCompositionId(), null,
 137             null, Pageable.unpaged());
 138         assertThat(acList).hasSize(2);
 139
 140         when(automationCompositionRepository
 141             .findAll(Mockito.any(), Mockito.any(Pageable.class)))
 142             .thenReturn(new PageImpl<>(inputAutomationCompositionsJpa));
 143         acList = automationCompositionProvider.getAutomationCompositions(automationComposition.getCompositionId(), null,
 144             null, PageRequest.of(0, 10));
 145         assertThat(acList).hasSize(2);
 146     }
 147
 148     @Test
 149     void testGetAutomationComposition() {
 150         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 151         assertThatThrownBy(
 152             () -> automationCompositionProvider.getAutomationComposition(automationComposition.getInstanceId()))
 153             .hasMessageMatching("AutomationComposition not found");
 154
 155         when(automationCompositionRepository.findById(automationComposition.getInstanceId().toString()))
 156             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 157         var ac = automationCompositionProvider.getAutomationComposition(automationComposition.getInstanceId());
 158         assertEquals(automationComposition, ac);
 159     }
 160
 161     @Test
 162     void testFindAutomationComposition() {
 163         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 164         var acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getInstanceId());
 165         assertThat(acOpt).isEmpty();
 166
 167         acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getKey().asIdentifier());
 168         assertThat(acOpt).isEmpty();
 169
 170         when(automationCompositionRepository.findById(automationComposition.getInstanceId().toString()))
 171             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 172         acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getInstanceId());
 173         assertEquals(automationComposition, acOpt.get());
 174
 175         when(automationCompositionRepository.findOne(Mockito.any()))
 176             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 177         acOpt = automationCompositionProvider.findAutomationComposition(automationComposition.getKey().asIdentifier());
 178         assertEquals(automationComposition, acOpt.get());
 179     }
 180
 181     @Test
 182     void testGetAcInstancesByCompositionId() {
 183         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 184         when(automationCompositionRepository.findByCompositionId(automationComposition.getCompositionId().toString()))
 185             .thenReturn(inputAutomationCompositionsJpa);
 186         var acList =
 187             automationCompositionProvider.getAcInstancesByCompositionId(automationComposition.getCompositionId());
 188         assertEquals(inputAutomationCompositions.getAutomationCompositionList(), acList);
 189     }
 190
 191     @Test
 192     void testGetAcInstancesInTransition() {
 193         inputAutomationCompositions.getAutomationCompositionList().get(0).setDeployState(DeployState.DEPLOYING);
 194         inputAutomationCompositions.getAutomationCompositionList().get(1).setLockState(LockState.LOCKING);
 195         inputAutomationCompositionsJpa.get(0).setDeployState(DeployState.DEPLOYING);
 196         inputAutomationCompositionsJpa.get(1).setLockState(LockState.LOCKING);
 197
 198         List<JpaAutomationComposition> res1 = new ArrayList<>();
 199         res1.add(inputAutomationCompositionsJpa.get(0));
 200
 201         when(automationCompositionRepository.findByDeployStateIn(List.of(DeployState.DEPLOYING,
 202             DeployState.UNDEPLOYING, DeployState.DELETING, DeployState.UPDATING, DeployState.MIGRATING)))
 203             .thenReturn(res1);
 204         when(automationCompositionRepository.findByLockStateIn(List.of(LockState.LOCKING, LockState.UNLOCKING)))
 205             .thenReturn(List.of(inputAutomationCompositionsJpa.get(1)));
 206         var acList = automationCompositionProvider.getAcInstancesInTransition();
 207         assertThat(acList).hasSize(2)
 208             .contains(inputAutomationCompositions.getAutomationCompositionList().get(0).getInstanceId())
 209             .contains(inputAutomationCompositions.getAutomationCompositionList().get(1).getInstanceId());
 210     }
 211
 212     @Test
 213     void testDeleteAutomationComposition() {
 214         assertThatThrownBy(() -> automationCompositionProvider.deleteAutomationComposition(UUID.randomUUID()))
 215             .hasMessageMatching(".*.failed, automation composition does not exist");
 216
 217         var automationComposition = inputAutomationCompositions.getAutomationCompositionList().get(0);
 218         when(automationCompositionRepository.findById(automationComposition.getInstanceId().toString()))
 219             .thenReturn(Optional.of(inputAutomationCompositionsJpa.get(0)));
 220
 221         var deletedAc =
 222             automationCompositionProvider.deleteAutomationComposition(automationComposition.getInstanceId());
 223         assertEquals(automationComposition, deletedAc);
 224     }
 225
 226     @Test
 227     void testDeleteElementById() {
 228         assertThatThrownBy(() -> automationCompositionProvider.deleteAutomationCompositionElement(null))
 229             .hasMessageMatching(ACELEMENT_ID_IS_NULL);
 230         var elementId = UUID.randomUUID();
 231         automationCompositionProvider.deleteAutomationCompositionElement(elementId);
 232         verify(acElementRepository).deleteById(elementId.toString());
 233     }
 234
 235     @Test
 236     void testValidateElementIds() {
 237         var ac = inputAutomationCompositions.getAutomationCompositionList().get(0);
 238
 239         var result = automationCompositionProvider.validateElementIds(ac);
 240         assertThat(result.isValid()).isTrue();
 241
 242         var jpaElement = new JpaAutomationCompositionElement(ac.getElements().values().iterator().next());
 243         when(acElementRepository.findAllById(anyIterable()))
 244             .thenReturn(List.of(jpaElement));
 245
 246         ac.setInstanceId(null);
 247         result = automationCompositionProvider.validateElementIds(ac);
 248         assertThat(result.isValid()).isFalse();
 249
 250         ac.setInstanceId(UUID.randomUUID());
 251         jpaElement.setInstanceId(UUID.randomUUID().toString());
 252         result = automationCompositionProvider.validateElementIds(ac);
 253         assertThat(result.isValid()).isFalse();
 254
 255         ac.setInstanceId(UUID.randomUUID());
 256         jpaElement.setInstanceId(ac.getInstanceId().toString());
 257         result = automationCompositionProvider.validateElementIds(ac);
 258         assertThat(result.isValid()).isTrue();
 259     }
 260
 261     @Test
 262     void testCopyAcElements() {
 263         var ac = inputAutomationCompositions.getAutomationCompositionList().get(0);
 264         automationCompositionProvider.copyAcElementsBeforeUpdate(ac);
 265
 266         verify(acRollbackRepository).save(any(JpaAutomationCompositionRollback.class));
 267     }
 268 }