Merge "Add Legacy Op Policy Persistence"

10 files changed, 301 insertions, 24 deletions

diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfConceptKey.java b/models-base/src/main/java/org/onap/policy/models/base/PfConceptKey.java
index 9f575851b..84239e5eb 100644
--- a/models-base/src/main/java/org/onap/policy/models/base/PfConceptKey.java
+++ b/models-base/src/main/java/org/onap/policy/models/base/PfConceptKey.java
@@ -177,6 +177,73 @@ public class PfConceptKey extends PfKey {
     }
 
     @Override
+    public boolean isNewerThan(@NonNull final PfKey otherKey) {
+        Assertions.instanceOf(otherKey, PfConceptKey.class);
+
+        final PfConceptKey otherConceptKey = (PfConceptKey) otherKey;
+
+        if (this.equals(otherConceptKey)) {
+            return false;
+        }
+
+        if (!this.getName().equals(otherConceptKey.getName())) {
+            return this.getName().compareTo(otherConceptKey.getName()) > 0;
+        }
+
+        final String[] thisVersionArray = getVersion().split("\\.");
+        final String[] otherVersionArray = otherConceptKey.getVersion().split("\\.");
+
+        // There must always be at least one element in each version
+        if (!thisVersionArray[0].equals(otherVersionArray[0])) {
+            return thisVersionArray[0].compareTo(otherVersionArray[0]) > 0;
+        }
+
+        if (thisVersionArray.length >= 2 && otherVersionArray.length >= 2
+                        && !thisVersionArray[1].equals(otherVersionArray[1])) {
+            return thisVersionArray[1].compareTo(otherVersionArray[1]) > 0;
+        }
+
+        if (thisVersionArray.length >= 3 && otherVersionArray.length >= 3
+                        && !thisVersionArray[2].equals(otherVersionArray[2])) {
+            return thisVersionArray[2].compareTo(otherVersionArray[2]) > 0;
+        }
+
+        return false;
+    }
+
+    @Override
+    public int getMajorVersion() {
+        final String[] versionArray = getVersion().split("\\.");
+
+        // There must always be at least one element in each version
+        return Integer.parseInt(versionArray[0]);
+    }
+
+    @Override
+    public int getMinorVersion() {
+        final String[] versionArray = getVersion().split("\\.");
+
+        if (versionArray.length >= 2) {
+            return Integer.parseInt(versionArray[1]);
+        }
+        else {
+            return 0;
+        }
+    }
+
+    @Override
+    public int getPatchVersion() {
+        final String[] versionArray = getVersion().split("\\.");
+
+        if (versionArray.length >= 3) {
+            return Integer.parseInt(versionArray[2]);
+        }
+        else {
+            return 0;
+        }
+    }
+
+    @Override
     public PfValidationResult validate(final PfValidationResult result) {
         final String nameValidationErrorMessage = Assertions.getStringParameterValidationMessage(NAME_TOKEN, name,
                         NAME_REGEXP);
diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfKey.java b/models-base/src/main/java/org/onap/policy/models/base/PfKey.java
index 6e9035e95..5407030ba 100644
--- a/models-base/src/main/java/org/onap/policy/models/base/PfKey.java
+++ b/models-base/src/main/java/org/onap/policy/models/base/PfKey.java
@@ -102,9 +102,38 @@ public abstract class PfKey extends PfConcept {
     public abstract boolean isCompatible(@NonNull PfKey otherKey);
 
     /**
+     * Check if this key is a newer version than the other key.
+     *
+     * @param otherKey the key to check against
+     * @return true, if this key is newer than the other key
+     */
+    public abstract boolean isNewerThan(@NonNull PfKey otherKey);
+
+    /**
      * Check if a key equals its null key.
      *
      * @return true, if the key is a null key
      */
     public abstract boolean isNullKey();
+
+    /**
+     * Get the major version of a key.
+     *
+     * @return the major version of a key
+     */
+    public abstract int getMajorVersion();
+
+    /**
+     * Get the minor version of a key.
+     *
+     * @return the minor version of a key
+     */
+    public abstract int getMinorVersion();
+
+    /**
+     * Get the patch version of a key.
+     *
+     * @return the patch version of a key
+     */
+    public abstract int getPatchVersion();
 }
diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java b/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java
index 57141c2fa..836707ef2 100644
--- a/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java
+++ b/models-base/src/main/java/org/onap/policy/models/base/PfKeyUse.java
@@ -111,6 +111,26 @@ public class PfKeyUse extends PfKey {
     }
 
     @Override
+    public boolean isNewerThan(@NonNull final PfKey otherKey) {
+        return usedKey.isCompatible(otherKey);
+    }
+
+    @Override
+    public int getMajorVersion() {
+        return usedKey.getMajorVersion();
+    }
+
+    @Override
+    public int getMinorVersion() {
+        return usedKey.getMinorVersion();
+    }
+
+    @Override
+    public int getPatchVersion() {
+        return usedKey.getPatchVersion();
+    }
+
+    @Override
     public void clean() {
         usedKey.clean();
     }
diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java b/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java
index 19e8beee9..185ccfa69 100644
--- a/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java
+++ b/models-base/src/main/java/org/onap/policy/models/base/PfReferenceKey.java
@@ -28,6 +28,7 @@ import javax.persistence.Embeddable;
 
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import lombok.NonNull;
 
 import org.onap.policy.common.utils.validation.Assertions;
 import org.onap.policy.models.base.PfValidationResult.ValidationResult;
@@ -305,7 +306,7 @@ public class PfReferenceKey extends PfKey {
     }
 
     @Override
-    public boolean isCompatible(final PfKey otherKey) {
+    public boolean isCompatible(@NonNull final PfKey otherKey) {
         if (!(otherKey instanceof PfReferenceKey)) {
             return false;
         }
@@ -315,6 +316,31 @@ public class PfReferenceKey extends PfKey {
     }
 
     @Override
+    public int getMajorVersion() {
+        return this.getParentConceptKey().getMajorVersion();
+    }
+
+    @Override
+    public int getMinorVersion() {
+        return this.getParentConceptKey().getMinorVersion();
+    }
+
+    @Override
+    public int getPatchVersion() {
+        return this.getParentConceptKey().getPatchVersion();
+    }
+
+
+    @Override
+    public boolean isNewerThan(@NonNull final PfKey otherKey) {
+        Assertions.instanceOf(otherKey, PfReferenceKey.class);
+
+        final PfReferenceKey otherReferenceKey = (PfReferenceKey) otherKey;
+
+        return this.getParentConceptKey().isNewerThan(otherReferenceKey.getParentConceptKey());
+    }
+
+    @Override
     public PfValidationResult validate(final PfValidationResult result) {
         final String parentNameValidationErrorMessage = Assertions.getStringParameterValidationMessage(PARENT_KEY_NAME,
                         parentKeyName, NAME_REGEXP);
diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java b/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java
index 8e77d3fcf..7bdd9a5f4 100644
--- a/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java
+++ b/models-base/src/main/java/org/onap/policy/models/base/PfUtils.java
@@ -21,6 +21,7 @@
 
 package org.onap.policy.models.base;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -72,7 +73,7 @@ public final class PfUtils {
      */
     public static <T> List<T> mapList(List<T> source, Function<T, T> mapFunc) {
         if (source == null) {
-            return null;
+            return new ArrayList<>();
         }
 
         return source.stream().map(mapFunc).collect(Collectors.toList());
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfKeyTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfKeyTest.java
index 848889cc3..a4c504788 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfKeyTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfKeyTest.java
@@ -42,9 +42,10 @@ public class PfKeyTest {
             new PfConceptKey("some bad key id");
             fail("This test should throw an exception");
         } catch (IllegalArgumentException e) {
-            assertEquals("parameter \"id\": value \"some bad key id\", "
+            assertEquals(
+                    "parameter \"id\": value \"some bad key id\", "
                             + "does not match regular expression \"[A-Za-z0-9\\-_\\.]+:[0-9].[0-9].[0-9]\"",
-                            e.getMessage());
+                    e.getMessage());
         }
 
         PfConceptKey someKey0 = new PfConceptKey();
@@ -110,19 +111,19 @@ public class PfKeyTest {
         assertFalse(someKey1.isCompatible(new DummyPfKey()));
 
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey0.validate(new PfValidationResult()).getValidationResult());
+                someKey0.validate(new PfValidationResult()).getValidationResult());
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey1.validate(new PfValidationResult()).getValidationResult());
+                someKey1.validate(new PfValidationResult()).getValidationResult());
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey2.validate(new PfValidationResult()).getValidationResult());
+                someKey2.validate(new PfValidationResult()).getValidationResult());
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey3.validate(new PfValidationResult()).getValidationResult());
+                someKey3.validate(new PfValidationResult()).getValidationResult());
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey4.validate(new PfValidationResult()).getValidationResult());
+                someKey4.validate(new PfValidationResult()).getValidationResult());
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey5.validate(new PfValidationResult()).getValidationResult());
+                someKey5.validate(new PfValidationResult()).getValidationResult());
         assertEquals(PfValidationResult.ValidationResult.VALID,
-                        someKey6.validate(new PfValidationResult()).getValidationResult());
+                someKey6.validate(new PfValidationResult()).getValidationResult());
 
         someKey0.clean();
         assertNotNull(someKey0.toString());
@@ -150,14 +151,14 @@ public class PfKeyTest {
     @Test
     public void testNullArguments() {
         try {
-            new PfConceptKey((String)null);
+            new PfConceptKey((String) null);
             fail("test should throw an exception here");
         } catch (Exception exc) {
             assertEquals("id is marked @NonNull but is null", exc.getMessage());
         }
 
         try {
-            new PfConceptKey((PfConceptKey)null);
+            new PfConceptKey((PfConceptKey) null);
             fail("id is marked @NonNull but is null");
         } catch (Exception exc) {
             assertEquals("copyConcept is marked @NonNull but is null", exc.getMessage());
@@ -207,9 +208,9 @@ public class PfKeyTest {
             nameField.set(testKey, "TheKey");
             nameField.setAccessible(false);
             assertEquals(
-                "name invalid-parameter name with value Key Name "
-                    + "does not match regular expression [A-Za-z0-9\\-_\\.]+",
-                validationResult.getMessageList().get(0).getMessage());
+                    "name invalid-parameter name with value Key Name "
+                            + "does not match regular expression [A-Za-z0-9\\-_\\.]+",
+                    validationResult.getMessageList().get(0).getMessage());
         } catch (Exception validationException) {
             fail("test should not throw an exception");
         }
@@ -223,11 +224,105 @@ public class PfKeyTest {
             versionField.set(testKey, "0.0.1");
             versionField.setAccessible(false);
             assertEquals(
-                "version invalid-parameter version with value Key Version "
-                    + "does not match regular expression [A-Za-z0-9.]+",
-                validationResult.getMessageList().get(0).getMessage());
+                    "version invalid-parameter version with value Key Version "
+                            + "does not match regular expression [A-Za-z0-9.]+",
+                    validationResult.getMessageList().get(0).getMessage());
         } catch (Exception validationException) {
             fail("test should not throw an exception");
         }
     }
+
+    @Test
+    public void testkeynewerThan() {
+        PfConceptKey key1 = new PfConceptKey("Key1", "1.2.3");
+
+        try {
+            key1.isNewerThan(null);
+            fail("test should throw an exception");
+        } catch (Exception exc) {
+            assertEquals("otherKey is marked @NonNull but is null", exc.getMessage());
+        }
+
+        try {
+            key1.isNewerThan(new PfReferenceKey());
+            fail("test should throw an exception");
+        } catch (Exception exc) {
+            assertEquals("org.onap.policy.models.base.PfReferenceKey is not "
+                    + "an instance of org.onap.policy.models.base.PfConceptKey", exc.getMessage());
+        }
+
+        assertFalse(key1.isNewerThan(key1));
+
+        PfConceptKey key1a = new PfConceptKey("Key1a", "1.2.3");
+        assertFalse(key1.isNewerThan(key1a));
+
+        PfConceptKey key1b = new PfConceptKey("Key0", "1.2.3");
+        assertTrue(key1.isNewerThan(key1b));
+
+        key1a.setName("Key1");
+        assertFalse(key1.isNewerThan(key1a));
+
+        key1a.setVersion("0.2.3");
+        assertTrue(key1.isNewerThan(key1a));
+        key1a.setVersion("2.2.3");
+        assertFalse(key1.isNewerThan(key1a));
+        key1a.setVersion("1.2.3");
+        assertFalse(key1.isNewerThan(key1a));
+
+        key1a.setVersion("1.1.3");
+        assertTrue(key1.isNewerThan(key1a));
+        key1a.setVersion("1.3.3");
+        assertFalse(key1.isNewerThan(key1a));
+        key1a.setVersion("1.2.3");
+        assertFalse(key1.isNewerThan(key1a));
+
+        key1a.setVersion("1.2.2");
+        assertTrue(key1.isNewerThan(key1a));
+        key1a.setVersion("1.2.4");
+        assertFalse(key1.isNewerThan(key1a));
+        key1a.setVersion("1.2.3");
+        assertFalse(key1.isNewerThan(key1a));
+
+        key1.setVersion("1");
+        assertFalse(key1.isNewerThan(key1a));
+        key1a.setVersion("1");
+        assertFalse(key1.isNewerThan(key1a));
+
+        PfReferenceKey refKey = new PfReferenceKey();
+
+        try {
+            refKey.isNewerThan(null);
+            fail("test should throw an exception");
+        } catch (Exception exc) {
+            assertEquals("otherKey is marked @NonNull but is null", exc.getMessage());
+        }
+
+        try {
+            refKey.isNewerThan(new PfConceptKey());
+            fail("test should throw an exception");
+        } catch (Exception exc) {
+            assertEquals("org.onap.policy.models.base.PfConceptKey is not "
+                    + "an instance of org.onap.policy.models.base.PfReferenceKey", exc.getMessage());
+        }
+
+        assertFalse(refKey.isNewerThan(refKey));
+    }
+
+    @Test
+    public void testmajorMinorPatch() {
+        PfConceptKey key = new PfConceptKey("Key", "1");
+        assertEquals(1, key.getMajorVersion());
+        assertEquals(0, key.getMinorVersion());
+        assertEquals(0, key.getPatchVersion());
+
+        key = new PfConceptKey("Key", "1.2");
+        assertEquals(1, key.getMajorVersion());
+        assertEquals(2, key.getMinorVersion());
+        assertEquals(0, key.getPatchVersion());
+
+        key = new PfConceptKey("Key", "1.2.3");
+        assertEquals(1, key.getMajorVersion());
+        assertEquals(2, key.getMinorVersion());
+        assertEquals(3, key.getPatchVersion());
+    }
 }
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java
index ccdc72dcd..72df28f04 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfKeyUseTest.java
@@ -131,5 +131,9 @@ public class PfKeyUseTest {
         } catch (Exception exc) {
             assertEquals("error copying concept key: Some error message", exc.getMessage());
         }
+
+        assertEquals(0, testKeyUse.getMajorVersion());
+        assertEquals(0, testKeyUse.getMinorVersion());
+        assertEquals(0, testKeyUse.getPatchVersion());
     }
 }
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java
index 64d4bc6b8..edf4466f8 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfReferenceKeyTest.java
@@ -58,6 +58,10 @@ public class PfReferenceKeyTest {
         testReferenceKey.setParentConceptKey(new PfConceptKey("PN", "0.0.1"));
         assertEquals("PN:0.0.1", testReferenceKey.getParentConceptKey().getId());
 
+        assertEquals(0, testReferenceKey.getMajorVersion());
+        assertEquals(0, testReferenceKey.getMinorVersion());
+        assertEquals(1, testReferenceKey.getPatchVersion());
+
         assertEquals(1, testReferenceKey.getKeys().size());
         assertFalse(testReferenceKey.isNullKey());
 
@@ -76,6 +80,13 @@ public class PfReferenceKeyTest {
         testReferenceKey.setLocalName("NLN");
         assertEquals("NLN", testReferenceKey.getLocalName());
 
+        try {
+            testReferenceKey.isCompatible(null);
+            fail("test should throw an exception here");
+        } catch (Exception exc) {
+            assertEquals("otherKey is marked @NonNull but is null", exc.getMessage());
+        }
+
         assertFalse(testReferenceKey.isCompatible(PfConceptKey.getNullKey()));
         assertFalse(testReferenceKey.isCompatible(PfReferenceKey.getNullKey()));
         assertTrue(testReferenceKey.isCompatible(testReferenceKey));
diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfUtilsTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfUtilsTest.java
index bdbab5c36..11ddf3132 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/PfUtilsTest.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/PfUtilsTest.java
@@ -1,4 +1,4 @@
-/*
+/*-
  * ============LICENSE_START=======================================================
  *  Copyright (C) 2019 Nordix Foundation.
  *  Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
@@ -23,7 +23,7 @@ package org.onap.policy.models.base;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Arrays;
 import java.util.List;
@@ -47,9 +47,10 @@ public class PfUtilsTest {
 
     @Test
     public void testMapList() {
-        assertNull(PfUtils.mapList(null, item -> {
+        List<Object> resultList = PfUtils.mapList(null, item -> {
             throw new RuntimeException("should not be invoked");
-        }));
+        });
+        assertTrue(resultList.isEmpty());
 
         List<String> origList = Arrays.asList("abc", "def");
         List<String> newList = PfUtils.mapList(origList, text -> text + "X");
diff --git a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java
index 6cf41e60c..f485b0d0f 100644
--- a/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java
+++ b/models-base/src/test/java/org/onap/policy/models/base/testconcepts/DummyPfKey.java
@@ -23,11 +23,13 @@ package org.onap.policy.models.base.testconcepts;
 import java.util.Arrays;
 import java.util.List;
 
+import lombok.NonNull;
+
 import org.onap.policy.models.base.PfConcept;
 import org.onap.policy.models.base.PfKey;
 import org.onap.policy.models.base.PfValidationResult;
 
-public class DummyPfKey  extends PfKey {
+public class DummyPfKey extends PfKey {
     private static final long serialVersionUID = 1L;
 
     @Override
@@ -94,4 +96,25 @@ public class DummyPfKey  extends PfKey {
     public PfConcept copyTo(PfConcept target) {
         return null;
     }
+
+    @Override
+    public boolean isNewerThan(@NonNull PfKey otherKey) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public int getMajorVersion() {
+        return 0;
+    }
+
+    @Override
+    public int getMinorVersion() {
+        return 0;
+    }
+
+    @Override
+    public int getPatchVersion() {
+        return 0;
+    }
 }