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.concepts;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.assertj.core.api.Assertions.assertThatCode;
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26 import static org.junit.jupiter.api.Assertions.assertEquals;
  27 import static org.junit.jupiter.api.Assertions.assertFalse;
  28 import static org.junit.jupiter.api.Assertions.assertNotEquals;
  29 import static org.junit.jupiter.api.Assertions.assertNotNull;
  30 import static org.junit.jupiter.api.Assertions.assertNull;
  31 import static org.junit.jupiter.api.Assertions.assertTrue;
  32
  33 import java.io.File;
  34 import java.util.LinkedHashMap;
  35 import org.junit.jupiter.api.Test;
  36 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  37 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
  38 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
  40 import org.onap.policy.common.utils.coder.CoderException;
  41 import org.onap.policy.common.utils.coder.StandardCoder;
  42 import org.onap.policy.models.base.PfConceptKey;
  43 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  44
  45 /**
  46  * Test the {@link JpaAutomationCompositionTest} class.
  47  */
  48 class JpaAutomationCompositionTest {
  49
  50     private static final String NULL_KEY_ERROR = "key is marked .*ull but is null";
  51
  52     @Test
  53     void testJpaAutomationCompositionConstructor() {
  54         assertThatThrownBy(() -> {
  55             new JpaAutomationComposition((JpaAutomationComposition) null);
  56         }).hasMessageMatching("copyConcept is marked .*ull but is null");
  57
  58         assertThatThrownBy(() -> {
  59             new JpaAutomationComposition((PfConceptKey) null);
  60         }).hasMessageMatching(NULL_KEY_ERROR);
  61
  62         assertThatThrownBy(() -> {
  63             new JpaAutomationComposition(null, null, null, null);
  64         }).hasMessageMatching(NULL_KEY_ERROR);
  65
  66         assertThatThrownBy(() -> {
  67             new JpaAutomationComposition(null, null, null, new LinkedHashMap<>());
  68         }).hasMessageMatching(NULL_KEY_ERROR);
  69
  70         assertThatThrownBy(() -> {
  71             new JpaAutomationComposition(null, null, AutomationCompositionState.UNINITIALISED, null);
  72         }).hasMessageMatching(NULL_KEY_ERROR);
  73
  74         assertThatThrownBy(() -> {
  75             new JpaAutomationComposition(null, null, AutomationCompositionState.UNINITIALISED, new LinkedHashMap<>());
  76         }).hasMessageMatching(NULL_KEY_ERROR);
  77
  78         assertThatThrownBy(() -> {
  79             new JpaAutomationComposition(null, new PfConceptKey(), null, null);
  80         }).hasMessageMatching(NULL_KEY_ERROR);
  81
  82         assertThatThrownBy(() -> {
  83             new JpaAutomationComposition(null, new PfConceptKey(), null, new LinkedHashMap<>());
  84         }).hasMessageMatching(NULL_KEY_ERROR);
  85
  86         assertThatThrownBy(() -> {
  87             new JpaAutomationComposition(null, new PfConceptKey(), AutomationCompositionState.UNINITIALISED, null);
  88         }).hasMessageMatching(NULL_KEY_ERROR);
  89
  90         assertThatThrownBy(() -> {
  91             new JpaAutomationComposition(null, new PfConceptKey(), AutomationCompositionState.UNINITIALISED,
  92                 new LinkedHashMap<>());
  93         }).hasMessageMatching(NULL_KEY_ERROR);
  94
  95         assertThatThrownBy(() -> {
  96             new JpaAutomationComposition(new PfConceptKey(), null, null, null);
  97         }).hasMessageMatching("definition is marked .*ull but is null");
  98
  99         assertThatThrownBy(() -> {
 100             new JpaAutomationComposition(new PfConceptKey(), null, null, new LinkedHashMap<>());
 101         }).hasMessageMatching("definition is marked .*ull but is null");
 102
 103         assertThatThrownBy(() -> {
 104             new JpaAutomationComposition(new PfConceptKey(), null, AutomationCompositionState.UNINITIALISED, null);
 105         }).hasMessageMatching("definition is marked .*ull but is null");
 106
 107         assertThatThrownBy(() -> {
 108             new JpaAutomationComposition(new PfConceptKey(), null, AutomationCompositionState.UNINITIALISED,
 109                 new LinkedHashMap<>());
 110         }).hasMessageMatching("definition is marked .*ull but is null");
 111
 112         assertThatThrownBy(() -> {
 113             new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(), null, null);
 114         }).hasMessageMatching("state is marked .*ull but is null");
 115
 116         assertThatThrownBy(() -> {
 117             new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(), null, new LinkedHashMap<>());
 118         }).hasMessageMatching("state is marked .*ull but is null");
 119
 120         assertThatThrownBy(() -> {
 121             new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(),
 122                 AutomationCompositionState.UNINITIALISED, null);
 123         }).hasMessageMatching("elements is marked .*ull but is null");
 124
 125         assertNotNull(new JpaAutomationComposition());
 126         assertNotNull(new JpaAutomationComposition((new PfConceptKey())));
 127         assertNotNull(new JpaAutomationComposition(new PfConceptKey(), new PfConceptKey(),
 128             AutomationCompositionState.UNINITIALISED, new LinkedHashMap<>()));
 129     }
 130
 131     @Test
 132     void testJpaAutomationComposition() {
 133         JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 134
 135         AutomationComposition participant = createAutomationCompositionInstance();
 136         assertEquals(participant, testJpaAutomationComposition.toAuthorative());
 137
 138         assertThatThrownBy(() -> {
 139             testJpaAutomationComposition.fromAuthorative(null);
 140         }).hasMessageMatching("automationComposition is marked .*ull but is null");
 141
 142         assertThatThrownBy(() -> new JpaAutomationComposition((JpaAutomationComposition) null))
 143             .isInstanceOf(NullPointerException.class);
 144
 145         JpaAutomationComposition testJpaAutomationCompositionFa = new JpaAutomationComposition();
 146         testJpaAutomationCompositionFa.setKey(null);
 147         testJpaAutomationCompositionFa.fromAuthorative(participant);
 148         assertEquals(testJpaAutomationComposition, testJpaAutomationCompositionFa);
 149         testJpaAutomationCompositionFa.setKey(PfConceptKey.getNullKey());
 150         testJpaAutomationCompositionFa.fromAuthorative(participant);
 151         assertEquals(testJpaAutomationComposition, testJpaAutomationCompositionFa);
 152         testJpaAutomationCompositionFa.setKey(new PfConceptKey("automation-composition", "0.0.1"));
 153         testJpaAutomationCompositionFa.fromAuthorative(participant);
 154         assertEquals(testJpaAutomationComposition, testJpaAutomationCompositionFa);
 155
 156         assertEquals("automation-composition", testJpaAutomationComposition.getKey().getName());
 157         assertEquals("automation-composition",
 158             new JpaAutomationComposition(createAutomationCompositionInstance()).getKey().getName());
 159         assertEquals("automation-composition",
 160             ((PfConceptKey) new JpaAutomationComposition(createAutomationCompositionInstance()).getKeys().get(0))
 161                 .getName());
 162
 163         testJpaAutomationComposition.clean();
 164         assertEquals("automation-composition", testJpaAutomationComposition.getKey().getName());
 165
 166         testJpaAutomationComposition.setDescription("   A Message   ");
 167         testJpaAutomationComposition.clean();
 168         assertEquals("A Message", testJpaAutomationComposition.getDescription());
 169
 170         JpaAutomationComposition testJpaAutomationComposition2 =
 171             new JpaAutomationComposition(testJpaAutomationComposition);
 172         assertEquals(testJpaAutomationComposition, testJpaAutomationComposition2);
 173     }
 174
 175     @Test
 176     void testJpaAutomationCompositionElementOrderedState() throws CoderException {
 177         AutomationComposition testAutomationComposition = createAutomationCompositionInstance();
 178         JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 179
 180         testJpaAutomationComposition.setOrderedState(null);
 181         assertEquals(testAutomationComposition, testJpaAutomationComposition.toAuthorative());
 182         testJpaAutomationComposition.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
 183
 184         AutomationComposition noOrderedStateAc = new StandardCoder().decode(
 185             new File("src/test/resources/json/AutomationCompositionNoOrderedState.json"), AutomationComposition.class);
 186
 187         JpaAutomationComposition noOrderedStateJpaAc = new JpaAutomationComposition(noOrderedStateAc);
 188         assertNull(noOrderedStateJpaAc.getOrderedState());
 189         noOrderedStateAc.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
 190         noOrderedStateJpaAc = new JpaAutomationComposition(noOrderedStateAc);
 191         assertEquals(testJpaAutomationComposition, noOrderedStateJpaAc);
 192
 193         AutomationCompositions automationCompositionsWithElements = new StandardCoder().decode(
 194             new File("src/test/resources/providers/TestAutomationCompositions.json"), AutomationCompositions.class);
 195
 196         JpaAutomationComposition jpaAutomationCompositionWithElements =
 197             new JpaAutomationComposition(automationCompositionsWithElements.getAutomationCompositionList().get(0));
 198         assertEquals(4, jpaAutomationCompositionWithElements.getElements().size());
 199         assertEquals(18, jpaAutomationCompositionWithElements.getKeys().size());
 200         assertThatCode(jpaAutomationCompositionWithElements::clean).doesNotThrowAnyException();
 201
 202         assertEquals(automationCompositionsWithElements.getAutomationCompositionList().get(0),
 203             jpaAutomationCompositionWithElements.toAuthorative());
 204     }
 205
 206     @Test
 207     void testJpaAutomationCompositionValidation() {
 208         JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 209
 210         assertThatThrownBy(() -> testJpaAutomationComposition.validate(null))
 211             .hasMessageMatching("fieldName is marked .*ull but is null");
 212
 213         assertTrue(testJpaAutomationComposition.validate("").isValid());
 214     }
 215
 216     @Test
 217     void testJpaAutomationCompositionCompareTo() {
 218         JpaAutomationComposition testJpaAutomationComposition = createJpaAutomationCompositionInstance();
 219
 220         JpaAutomationComposition otherJpaAutomationComposition =
 221             new JpaAutomationComposition(testJpaAutomationComposition);
 222         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 223         assertEquals(-1, testJpaAutomationComposition.compareTo(null));
 224         assertEquals(0, testJpaAutomationComposition.compareTo(testJpaAutomationComposition));
 225         assertNotEquals(0, testJpaAutomationComposition.compareTo(new DummyJpaAutomationCompositionChild()));
 226
 227         testJpaAutomationComposition.setKey(new PfConceptKey("BadValue", "0.0.1"));
 228         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 229         testJpaAutomationComposition.setKey(new PfConceptKey("automation-composition", "0.0.1"));
 230         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 231
 232         testJpaAutomationComposition.setDefinition(new PfConceptKey("BadValue", "0.0.1"));
 233         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 234         testJpaAutomationComposition.setDefinition(new PfConceptKey("automationCompositionDefinitionName", "0.0.1"));
 235         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 236
 237         testJpaAutomationComposition.setState(AutomationCompositionState.PASSIVE);
 238         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 239         testJpaAutomationComposition.setState(AutomationCompositionState.UNINITIALISED);
 240         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 241
 242         testJpaAutomationComposition.setOrderedState(AutomationCompositionOrderedState.PASSIVE);
 243         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 244         testJpaAutomationComposition.setOrderedState(AutomationCompositionOrderedState.UNINITIALISED);
 245         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 246
 247         testJpaAutomationComposition.setDescription("A description");
 248         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 249         testJpaAutomationComposition.setDescription(null);
 250         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 251
 252         testJpaAutomationComposition.setPrimed(true);
 253         assertNotEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 254         testJpaAutomationComposition.setPrimed(false);
 255         assertEquals(0, testJpaAutomationComposition.compareTo(otherJpaAutomationComposition));
 256
 257         assertEquals(testJpaAutomationComposition, new JpaAutomationComposition(testJpaAutomationComposition));
 258     }
 259
 260     @Test
 261     void testJpaAutomationCompositionLombok() {
 262         assertNotNull(new AutomationComposition());
 263         JpaAutomationComposition ac0 = new JpaAutomationComposition();
 264
 265         assertThat(ac0.toString()).contains("JpaAutomationComposition(");
 266         assertThat(ac0.hashCode()).isNotZero();
 267         assertEquals(ac0, ac0);
 268         assertNotEquals(null, ac0);
 269
 270         JpaAutomationComposition ac1 = new JpaAutomationComposition();
 271
 272         ac1.setDefinition(new PfConceptKey("defName", "0.0.1"));
 273         ac1.setDescription("Description");
 274         ac1.setElements(new LinkedHashMap<>());
 275         ac1.setKey(new PfConceptKey("participant", "0.0.1"));
 276         ac1.setState(AutomationCompositionState.UNINITIALISED);
 277
 278         assertThat(ac1.toString()).contains("AutomationComposition(");
 279         assertNotEquals(0, ac1.hashCode());
 280         assertNotEquals(ac1, ac0);
 281         assertNotEquals(null, ac1);
 282
 283         assertNotEquals(ac1, ac0);
 284
 285         JpaAutomationComposition ac2 = new JpaAutomationComposition();
 286         assertEquals(ac2, ac0);
 287     }
 288
 289     private JpaAutomationComposition createJpaAutomationCompositionInstance() {
 290         AutomationComposition testAutomationComposition = createAutomationCompositionInstance();
 291         JpaAutomationComposition testJpaAutomationComposition = new JpaAutomationComposition();
 292         testJpaAutomationComposition.setKey(null);
 293         testJpaAutomationComposition.fromAuthorative(testAutomationComposition);
 294         testJpaAutomationComposition.setKey(PfConceptKey.getNullKey());
 295         testJpaAutomationComposition.fromAuthorative(testAutomationComposition);
 296
 297         return testJpaAutomationComposition;
 298     }
 299
 300     private AutomationComposition createAutomationCompositionInstance() {
 301         AutomationComposition testAutomationComposition = new AutomationComposition();
 302         testAutomationComposition.setName("automation-composition");
 303         testAutomationComposition.setVersion("0.0.1");
 304         testAutomationComposition
 305             .setDefinition(new ToscaConceptIdentifier("automationCompositionDefinitionName", "0.0.1"));
 306         testAutomationComposition.setElements(new LinkedHashMap<>());
 307
 308         return testAutomationComposition;
 309     }
 310 }