models-base/src/test/java/org/onap/policy/models/base/PfKeyTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 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.models.base;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.fail;
  28
  29 import java.lang.reflect.Field;
  30
  31 import org.junit.Test;
  32
  33 import org.onap.policy.models.base.PfKey.Compatibility;
  34 import org.onap.policy.models.base.testconcepts.DummyPfConcept;
  35 import org.onap.policy.models.base.testconcepts.DummyPfKey;
  36
  37 public class PfKeyTest {
  38
  39     @Test
  40     public void testConceptKey() {
  41         try {
  42             new PfConceptKey("some bad key id");
  43             fail("This test should throw an exception");
  44         } catch (IllegalArgumentException e) {
  45             assertEquals(
  46                     "parameter \"id\": value \"some bad key id\", "
  47                             + "does not match regular expression \"[A-Za-z0-9\\-_\\.]+:[0-9].[0-9].[0-9]\"",
  48                     e.getMessage());
  49         }
  50
  51         try {
  52             new PfConceptKey((PfConceptKey) null);
  53             fail("This test should throw an exception");
  54         } catch (Exception e) {
  55             assertEquals("copyConcept is marked @NonNull but is null", e.getMessage());
  56         }
  57
  58         PfConceptKey someKey0 = new PfConceptKey();
  59         assertEquals(PfConceptKey.getNullKey(), someKey0);
  60
  61         PfConceptKey someKey1 = new PfConceptKey("name", "0.0.1");
  62         PfConceptKey someKey2 = new PfConceptKey(someKey1);
  63         PfConceptKey someKey3 = new PfConceptKey(someKey1.getId());
  64         assertEquals(someKey1, someKey2);
  65         assertEquals(someKey1, someKey3);
  66         assertFalse(someKey1.isNullVersion());
  67
  68         assertEquals(someKey2, someKey1.getKey());
  69         assertEquals(1, someKey1.getKeys().size());
  70
  71         someKey0.setName("zero");
  72         someKey0.setVersion("0.0.2");
  73
  74         someKey3.setVersion("0.0.2");
  75
  76         PfConceptKey someKey4 = new PfConceptKey(someKey1);
  77         someKey4.setVersion("0.1.2");
  78
  79         PfConceptKey someKey4a = new PfConceptKey(someKey1);
  80         someKey4a.setVersion("0");
  81
  82         PfConceptKey someKey5 = new PfConceptKey(someKey1);
  83         someKey5.setVersion("1.2.2");
  84
  85         PfConceptKey someKey6 = new PfConceptKey(someKey1);
  86         someKey6.setVersion("3");
  87
  88         assertEquals("name:0.1.2", someKey4.getId());
  89
  90         PfConcept pfc = new DummyPfConcept();
  91         assertEquals(PfConceptKey.getNullKey().getId(), pfc.getId());
  92
  93         assertTrue(PfConceptKey.getNullKey().matchesId(pfc.getId()));
  94
  95         assertTrue(PfConceptKey.getNullKey().isNullKey());
  96
  97         try {
  98             PfConceptKey.getNullKey().matchesId(null);
  99             fail("test should throw an exception");
 100         } catch (Exception exc) {
 101             assertEquals("id is marked @NonNull but is null", exc.getMessage());
 102         }
 103
 104         assertEquals(Compatibility.DIFFERENT, someKey0.getCompatibility(new DummyPfKey()));
 105         assertEquals(Compatibility.DIFFERENT, someKey0.getCompatibility(someKey1));
 106         assertEquals(Compatibility.IDENTICAL, someKey2.getCompatibility(someKey1));
 107         assertEquals(Compatibility.PATCH, someKey3.getCompatibility(someKey1));
 108         assertEquals(Compatibility.MINOR, someKey4.getCompatibility(someKey1));
 109         assertEquals(Compatibility.PATCH, someKey4a.getCompatibility(someKey1));
 110         assertEquals(Compatibility.PATCH, someKey1.getCompatibility(someKey4a));
 111         assertEquals(Compatibility.MAJOR, someKey5.getCompatibility(someKey1));
 112         assertEquals(Compatibility.MAJOR, someKey6.getCompatibility(someKey1));
 113
 114         assertTrue(someKey1.isCompatible(someKey2));
 115         assertTrue(someKey1.isCompatible(someKey3));
 116         assertTrue(someKey1.isCompatible(someKey4));
 117         assertFalse(someKey1.isCompatible(someKey0));
 118         assertFalse(someKey1.isCompatible(someKey5));
 119         assertFalse(someKey1.isCompatible(new DummyPfKey()));
 120
 121         assertEquals(PfValidationResult.ValidationResult.VALID,
 122                 someKey0.validate(new PfValidationResult()).getValidationResult());
 123         assertEquals(PfValidationResult.ValidationResult.VALID,
 124                 someKey1.validate(new PfValidationResult()).getValidationResult());
 125         assertEquals(PfValidationResult.ValidationResult.VALID,
 126                 someKey2.validate(new PfValidationResult()).getValidationResult());
 127         assertEquals(PfValidationResult.ValidationResult.VALID,
 128                 someKey3.validate(new PfValidationResult()).getValidationResult());
 129         assertEquals(PfValidationResult.ValidationResult.VALID,
 130                 someKey4.validate(new PfValidationResult()).getValidationResult());
 131         assertEquals(PfValidationResult.ValidationResult.VALID,
 132                 someKey5.validate(new PfValidationResult()).getValidationResult());
 133         assertEquals(PfValidationResult.ValidationResult.VALID,
 134                 someKey6.validate(new PfValidationResult()).getValidationResult());
 135
 136         someKey0.clean();
 137         assertNotNull(someKey0.toString());
 138
 139         PfConceptKey someKey7 = new PfConceptKey(someKey1);
 140         assertEquals(244799191, someKey7.hashCode());
 141         assertEquals(0, someKey7.compareTo(someKey1));
 142         assertEquals(-12, someKey7.compareTo(someKey0));
 143
 144         try {
 145             someKey0.compareTo(null);
 146             fail("test should throw an exception here");
 147         } catch (NullPointerException e) {
 148             assertEquals("otherObj is marked @NonNull but is null", e.getMessage());
 149         }
 150
 151         assertEquals(0, someKey0.compareTo(someKey0));
 152         assertEquals(266127751, someKey0.compareTo(new DummyPfKey()));
 153
 154         assertFalse(someKey0.equals(null));
 155         assertTrue(someKey0.equals(someKey0));
 156         assertFalse(((PfKey) someKey0).equals(new DummyPfKey()));
 157     }
 158
 159     @Test
 160     public void testNullArguments() {
 161         try {
 162             new PfConceptKey((String) null);
 163             fail("test should throw an exception here");
 164         } catch (Exception exc) {
 165             assertEquals("id is marked @NonNull but is null", exc.getMessage());
 166         }
 167
 168         try {
 169             new PfConceptKey((PfConceptKey) null);
 170             fail("id is marked @NonNull but is null");
 171         } catch (Exception exc) {
 172             assertEquals("copyConcept is marked @NonNull but is null", exc.getMessage());
 173         }
 174
 175         try {
 176             new PfConceptKey(null, null);
 177             fail("id is marked @NonNull but is null");
 178         } catch (Exception exc) {
 179             assertEquals("name is marked @NonNull but is null", exc.getMessage());
 180         }
 181
 182         try {
 183             new PfConceptKey("name", null);
 184             fail("id is marked @NonNull but is null");
 185         } catch (Exception exc) {
 186             assertEquals("version is marked @NonNull but is null", exc.getMessage());
 187         }
 188
 189         try {
 190             new PfConceptKey(null, "0.0.1");
 191             fail("id is marked @NonNull but is null");
 192         } catch (Exception exc) {
 193             assertEquals("name is marked @NonNull but is null", exc.getMessage());
 194         }
 195
 196         try {
 197             PfConceptKey key = new PfConceptKey("AKey", "0.0.1");
 198             key.isCompatible(null);
 199             fail("id is marked @NonNull but is null");
 200         } catch (Exception exc) {
 201             assertEquals("otherKey is marked @NonNull but is null", exc.getMessage());
 202         }
 203     }
 204
 205     @Test
 206     public void testValidation() {
 207         PfConceptKey testKey = new PfConceptKey("TheKey", "0.0.1");
 208         assertEquals("TheKey:0.0.1", testKey.getId());
 209
 210         try {
 211             Field nameField = testKey.getClass().getDeclaredField("name");
 212             nameField.setAccessible(true);
 213             nameField.set(testKey, "Key Name");
 214             PfValidationResult validationResult = new PfValidationResult();
 215             testKey.validate(validationResult);
 216             nameField.set(testKey, "TheKey");
 217             nameField.setAccessible(false);
 218             assertEquals(
 219                     "name invalid-parameter name with value Key Name "
 220                             + "does not match regular expression [A-Za-z0-9\\-_\\.]+",
 221                     validationResult.getMessageList().get(0).getMessage());
 222         } catch (Exception validationException) {
 223             fail("test should not throw an exception");
 224         }
 225
 226         try {
 227             Field versionField = testKey.getClass().getDeclaredField("version");
 228             versionField.setAccessible(true);
 229             versionField.set(testKey, "Key Version");
 230             PfValidationResult validationResult = new PfValidationResult();
 231             testKey.validate(validationResult);
 232             versionField.set(testKey, "0.0.1");
 233             versionField.setAccessible(false);
 234             assertEquals(
 235                     "version invalid-parameter version with value Key Version "
 236                             + "does not match regular expression [A-Za-z0-9.]+",
 237                     validationResult.getMessageList().get(0).getMessage());
 238         } catch (Exception validationException) {
 239             fail("test should not throw an exception");
 240         }
 241     }
 242
 243     @Test
 244     public void testkeynewerThan() {
 245         PfConceptKey key1 = new PfConceptKey("Key1", "1.2.3");
 246
 247         try {
 248             key1.isNewerThan(null);
 249             fail("test should throw an exception");
 250         } catch (Exception exc) {
 251             assertEquals("otherKey is marked @NonNull but is null", exc.getMessage());
 252         }
 253
 254         try {
 255             key1.isNewerThan(new PfReferenceKey());
 256             fail("test should throw an exception");
 257         } catch (Exception exc) {
 258             assertEquals("org.onap.policy.models.base.PfReferenceKey is not "
 259                     + "an instance of org.onap.policy.models.base.PfConceptKey", exc.getMessage());
 260         }
 261
 262         assertFalse(key1.isNewerThan(key1));
 263
 264         PfConceptKey key1a = new PfConceptKey("Key1a", "1.2.3");
 265         assertFalse(key1.isNewerThan(key1a));
 266
 267         PfConceptKey key1b = new PfConceptKey("Key0", "1.2.3");
 268         assertTrue(key1.isNewerThan(key1b));
 269
 270         key1a.setName("Key1");
 271         assertFalse(key1.isNewerThan(key1a));
 272
 273         key1a.setVersion("0.2.3");
 274         assertTrue(key1.isNewerThan(key1a));
 275         key1a.setVersion("2.2.3");
 276         assertFalse(key1.isNewerThan(key1a));
 277         key1a.setVersion("1.2.3");
 278         assertFalse(key1.isNewerThan(key1a));
 279
 280         key1a.setVersion("1.1.3");
 281         assertTrue(key1.isNewerThan(key1a));
 282         key1a.setVersion("1.3.3");
 283         assertFalse(key1.isNewerThan(key1a));
 284         key1a.setVersion("1.2.3");
 285         assertFalse(key1.isNewerThan(key1a));
 286
 287         key1a.setVersion("1.2.2");
 288         assertTrue(key1.isNewerThan(key1a));
 289         key1a.setVersion("1.2.4");
 290         assertFalse(key1.isNewerThan(key1a));
 291         key1a.setVersion("1.2.3");
 292         assertFalse(key1.isNewerThan(key1a));
 293
 294         key1.setVersion("1");
 295         assertFalse(key1.isNewerThan(key1a));
 296         key1a.setVersion("1");
 297         assertFalse(key1.isNewerThan(key1a));
 298
 299         PfReferenceKey refKey = new PfReferenceKey();
 300
 301         try {
 302             refKey.isNewerThan(null);
 303             fail("test should throw an exception");
 304         } catch (Exception exc) {
 305             assertEquals("otherKey is marked @NonNull but is null", exc.getMessage());
 306         }
 307
 308         try {
 309             refKey.isNewerThan(new PfConceptKey());
 310             fail("test should throw an exception");
 311         } catch (Exception exc) {
 312             assertEquals("org.onap.policy.models.base.PfConceptKey is not "
 313                     + "an instance of org.onap.policy.models.base.PfReferenceKey", exc.getMessage());
 314         }
 315
 316         assertFalse(refKey.isNewerThan(refKey));
 317     }
 318
 319     @Test
 320     public void testmajorMinorPatch() {
 321         PfConceptKey key = new PfConceptKey("Key", "1");
 322         assertEquals(1, key.getMajorVersion());
 323         assertEquals(0, key.getMinorVersion());
 324         assertEquals(0, key.getPatchVersion());
 325
 326         key = new PfConceptKey("Key", "1.2");
 327         assertEquals(1, key.getMajorVersion());
 328         assertEquals(2, key.getMinorVersion());
 329         assertEquals(0, key.getPatchVersion());
 330
 331         key = new PfConceptKey("Key", "1.2.3");
 332         assertEquals(1, key.getMajorVersion());
 333         assertEquals(2, key.getMinorVersion());
 334         assertEquals(3, key.getPatchVersion());
 335     }
 336 }