From cee84a9344f35356f86384b0d48127f5a83e3776 Mon Sep 17 00:00:00 2001 From: liamfallon Date: Tue, 26 Mar 2019 22:31:43 +0000 Subject: Add Legacy Op Policy Persistence Legacy operational policies now fully supported for serialization and persistence from provider through to database and back. Unit test coverage completed also Issue-ID: POLICY-1095 Change-Id: I65755859c94b50edee537d2685f51a7838c6541f Signed-off-by: liamfallon --- .../org/onap/policy/models/base/PfConceptKey.java | 67 +++++++++++ .../java/org/onap/policy/models/base/PfKey.java | 29 +++++ .../java/org/onap/policy/models/base/PfKeyUse.java | 20 ++++ .../onap/policy/models/base/PfReferenceKey.java | 28 ++++- .../java/org/onap/policy/models/base/PfUtils.java | 3 +- .../org/onap/policy/models/base/PfKeyTest.java | 129 ++++++++++++++++++--- .../org/onap/policy/models/base/PfKeyUseTest.java | 4 + .../policy/models/base/PfReferenceKeyTest.java | 11 ++ .../org/onap/policy/models/base/PfUtilsTest.java | 9 +- .../models/base/testconcepts/DummyPfKey.java | 25 +++- 10 files changed, 301 insertions(+), 24 deletions(-) (limited to 'models-base') 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 @@ -176,6 +176,73 @@ public class PfConceptKey extends PfKey { return !(compatibility == Compatibility.DIFFERENT || compatibility == Compatibility.MAJOR); } + @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, 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 @@ -101,10 +101,39 @@ 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 @@ -110,6 +110,26 @@ public class PfKeyUse extends PfKey { return usedKey.isCompatible(otherKey); } + @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; } @@ -314,6 +315,31 @@ public class PfReferenceKey extends PfKey { return this.getParentConceptKey().isCompatible(otherReferenceKey.getParentConceptKey()); } + @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, 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 List mapList(List source, Function 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 resultList = PfUtils.mapList(null, item -> { throw new RuntimeException("should not be invoked"); - })); + }); + assertTrue(resultList.isEmpty()); List origList = Arrays.asList("abc", "def"); List 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; + } } -- cgit 1.2.3-korg