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