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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2021-2023 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.assertThrows;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.mock;
  28 import static org.mockito.Mockito.when;
  29
  30 import java.util.ArrayList;
  31 import java.util.List;
  32 import java.util.Optional;
  33 import java.util.UUID;
  34 import java.util.stream.Collectors;
  35 import org.junit.jupiter.api.BeforeEach;
  36 import org.junit.jupiter.api.Test;
  37 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  38 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  39 import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
  40 import org.onap.policy.clamp.models.acm.concepts.Participant;
  41 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationComposition;
  42 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaNodeTemplateState;
  43 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaParticipant;
  44 import org.onap.policy.clamp.models.acm.persistence.repository.AutomationCompositionElementRepository;
  45 import org.onap.policy.clamp.models.acm.persistence.repository.NodeTemplateStateRepository;
  46 import org.onap.policy.clamp.models.acm.persistence.repository.ParticipantRepository;
  47 import org.onap.policy.common.utils.coder.Coder;
  48 import org.onap.policy.common.utils.coder.StandardCoder;
  49 import org.onap.policy.common.utils.resources.ResourceUtils;
  50 import org.onap.policy.models.base.PfModelRuntimeException;
  51
  52 class ParticipantProviderTest {
  53
  54     private static final Coder CODER = new StandardCoder();
  55     private static final String PARTICIPANT_JSON = "src/test/resources/providers/TestParticipant.json";
  56
  57     private static final String AUTOMATION_COMPOSITION_JSON =
  58         "src/test/resources/providers/TestAutomationCompositions.json";
  59
  60     private static final String NODE_TEMPLATE_STATE_JSON = "src/test/resources/providers/NodeTemplateState.json";
  61     private static final String LIST_IS_NULL = ".*. is marked .*ull but is null";
  62     private static final UUID INVALID_ID = UUID.randomUUID();
  63
  64     private final List<Participant> inputParticipants = new ArrayList<>();
  65     private List<JpaParticipant> jpaParticipantList;
  66     private final String originalJson = ResourceUtils.getResourceAsString(PARTICIPANT_JSON);
  67
  68     private AutomationCompositions inputAutomationCompositions;
  69     private List<JpaAutomationComposition> inputAutomationCompositionsJpa;
  70     private final String originalAcJson = ResourceUtils.getResourceAsString(AUTOMATION_COMPOSITION_JSON);
  71
  72     private final String nodeTemplateStatesJson = ResourceUtils.getResourceAsString(NODE_TEMPLATE_STATE_JSON);
  73
  74     private List<NodeTemplateState> nodeTemplateStateList = new ArrayList<>();
  75     private List<JpaNodeTemplateState> jpaNodeTemplateStateList;
  76
  77     @BeforeEach
  78     void beforeSetup() throws Exception {
  79         inputParticipants.add(CODER.decode(originalJson, Participant.class));
  80         jpaParticipantList = ProviderUtils.getJpaAndValidateList(inputParticipants, JpaParticipant::new, "participant");
  81
  82         inputAutomationCompositions = CODER.decode(originalAcJson, AutomationCompositions.class);
  83         inputAutomationCompositionsJpa =
  84             ProviderUtils.getJpaAndValidateList(inputAutomationCompositions.getAutomationCompositionList(),
  85                 JpaAutomationComposition::new, "automation compositions");
  86
  87         nodeTemplateStateList.add(CODER.decode(nodeTemplateStatesJson, NodeTemplateState.class));
  88         nodeTemplateStateList.get(0).setState(AcTypeState.COMMISSIONED);
  89         jpaNodeTemplateStateList = ProviderUtils.getJpaAndValidateList(nodeTemplateStateList,
  90             JpaNodeTemplateState::new, "node template state");
  91     }
  92
  93     @Test
  94     void testParticipantSave() {
  95         var participantRepository = mock(ParticipantRepository.class);
  96         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
  97         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
  98
  99         var participantProvider = new ParticipantProvider(participantRepository,
 100             automationCompositionElementRepository, nodeTemplateStateRepository);
 101
 102         assertThatThrownBy(() -> participantProvider.saveParticipant(null)).hasMessageMatching(LIST_IS_NULL);
 103
 104         when(participantRepository.save(any())).thenReturn(jpaParticipantList.get(0));
 105
 106         var savedParticipant = participantProvider.saveParticipant(inputParticipants.get(0));
 107         savedParticipant.setParticipantId(inputParticipants.get(0).getParticipantId());
 108
 109         assertThat(savedParticipant).usingRecursiveComparison().isEqualTo(inputParticipants.get(0));
 110     }
 111
 112     @Test
 113     void testParticipantUpdate() {
 114         var participantRepository = mock(ParticipantRepository.class);
 115         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 116         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 117
 118         var participantProvider = new ParticipantProvider(participantRepository,
 119             automationCompositionElementRepository, nodeTemplateStateRepository);
 120
 121         assertThatThrownBy(() -> participantProvider.updateParticipant(null))
 122             .hasMessageMatching(LIST_IS_NULL);
 123
 124         when(participantRepository.save(any())).thenReturn(jpaParticipantList.get(0));
 125
 126         var updatedParticipant = participantProvider.updateParticipant(inputParticipants.get(0));
 127         updatedParticipant.setParticipantId(inputParticipants.get(0).getParticipantId());
 128         assertThat(updatedParticipant).usingRecursiveComparison().isEqualTo(inputParticipants.get(0));
 129     }
 130
 131     @Test
 132     void testGetAutomationCompositions() {
 133         var participantRepository = mock(ParticipantRepository.class);
 134         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 135         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 136         var participantProvider = new ParticipantProvider(participantRepository,
 137             automationCompositionElementRepository, nodeTemplateStateRepository);
 138
 139
 140         assertThat(participantProvider.findParticipant(INVALID_ID)).isEmpty();
 141
 142         when(participantRepository.findAll()).thenReturn(jpaParticipantList);
 143         assertThat(participantProvider.getParticipants()).hasSize(inputParticipants.size());
 144
 145         assertThatThrownBy(() -> participantProvider.getParticipantById(inputParticipants.get(0).getParticipantId()))
 146                 .hasMessageMatching("Participant Not Found with ID: " + inputParticipants.get(0).getParticipantId());
 147
 148         when(participantRepository.findById(any())).thenReturn(
 149             Optional.ofNullable(jpaParticipantList.get(0)));
 150
 151         var participant = participantProvider.getParticipantById(inputParticipants.get(0)
 152             .getParticipantId());
 153
 154         assertThat(inputParticipants.get(0)).usingRecursiveComparison().isEqualTo(participant);
 155     }
 156
 157     @Test
 158     void testEmptyParticipant() {
 159         var participantRepository = mock(ParticipantRepository.class);
 160         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 161         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 162         var participantProvider = new ParticipantProvider(participantRepository,
 163             automationCompositionElementRepository, nodeTemplateStateRepository);
 164
 165         assertThatThrownBy(() -> participantProvider.getParticipantById(INVALID_ID)).isInstanceOf(
 166             PfModelRuntimeException.class).hasMessageMatching("Participant Not Found with ID:.*.");
 167     }
 168
 169     @Test
 170     void testDeleteParticipant() {
 171         var participantRepository = mock(ParticipantRepository.class);
 172         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 173         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 174         var participantProvider = new ParticipantProvider(participantRepository,
 175             automationCompositionElementRepository, nodeTemplateStateRepository);
 176
 177         var participantId = inputParticipants.get(0).getParticipantId();
 178         assertThatThrownBy(() -> participantProvider.deleteParticipant(participantId))
 179             .hasMessageMatching(".*.failed, participant does not exist");
 180
 181         when(participantRepository.findById(participantId.toString()))
 182             .thenReturn(Optional.of(jpaParticipantList.get(0)));
 183
 184         var deletedParticipant = participantProvider.deleteParticipant(participantId);
 185         assertThat(inputParticipants.get(0)).usingRecursiveComparison().isEqualTo(deletedParticipant);
 186     }
 187
 188     @Test
 189     void testGetAutomationCompositionElements() {
 190         var participantRepository = mock(ParticipantRepository.class);
 191         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 192         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 193         var participantProvider = new ParticipantProvider(participantRepository,
 194             automationCompositionElementRepository, nodeTemplateStateRepository);
 195
 196         var acElementList = inputAutomationCompositionsJpa
 197             .stream().map(c -> c.getElements()).collect(Collectors.toList());
 198
 199         when(automationCompositionElementRepository.findByParticipantId(any())).thenReturn(acElementList.get(0));
 200
 201         var listOfAcElements = participantProvider.getAutomationCompositionElements(UUID.randomUUID());
 202
 203         assertThat(acElementList.get(0).equals(listOfAcElements));
 204
 205
 206     }
 207
 208     @Test
 209     void testGetAcNodeTemplateState() {
 210         var participantRepository = mock(ParticipantRepository.class);
 211         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 212         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 213         when(nodeTemplateStateRepository.findByParticipantId(any())).thenReturn(jpaNodeTemplateStateList);
 214
 215         var participantProvider = new ParticipantProvider(participantRepository,
 216             automationCompositionElementRepository, nodeTemplateStateRepository);
 217
 218         var listOfNodeTemplateState = participantProvider.getAcNodeTemplateStates(
 219             UUID.fromString(jpaParticipantList.get(0).getParticipantId()));
 220
 221         assertThat(listOfNodeTemplateState.equals(nodeTemplateStateList));
 222
 223     }
 224
 225     @Test
 226     void testNotNullExceptions() {
 227         var participantRepository = mock(ParticipantRepository.class);
 228         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 229         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 230
 231         var participantProvider = new ParticipantProvider(participantRepository,
 232             automationCompositionElementRepository, nodeTemplateStateRepository);
 233
 234         assertThrows(NullPointerException.class, () -> participantProvider.getParticipantById(null));
 235         assertThrows(NullPointerException.class, () -> participantProvider.findParticipant(null));
 236         assertThrows(NullPointerException.class, () -> participantProvider.saveParticipant(null));
 237         assertThrows(NullPointerException.class, () -> participantProvider.updateParticipant(null));
 238         assertThrows(NullPointerException.class, () -> participantProvider.deleteParticipant(null));
 239         assertThrows(NullPointerException.class, () -> participantProvider.getAutomationCompositionElements(null));
 240         assertThrows(NullPointerException.class, () -> participantProvider.getAcNodeTemplateStates(null));
 241
 242
 243     }
 244
 245     @Test
 246     void testGetSupportedElementMap() {
 247         var participantRepository = mock(ParticipantRepository.class);
 248         var automationCompositionElementRepository = mock(AutomationCompositionElementRepository.class);
 249         var nodeTemplateStateRepository = mock(NodeTemplateStateRepository.class);
 250         when(participantRepository.findAll()).thenReturn(jpaParticipantList);
 251         var participantProvider = new ParticipantProvider(participantRepository,
 252             automationCompositionElementRepository, nodeTemplateStateRepository);
 253
 254         var result = participantProvider.getSupportedElementMap();
 255         assertThat(result).hasSize(2);
 256     }
 257 }