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