Add PDP-Policy deployment table to DB

Added a table to record the PDP policy deployment status, which is
required for making PAP stateless.

Issue-ID: POLICY-2648
Change-Id: Ibe40ce00aca7a600051edcac49e55651c1c0164f
Signed-off-by: Jim Hahn <jrh3@att.com>

2 files changed, 345 insertions, 1 deletions

diff --git a/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/concepts/JpaPdpPolicyStatusTest.java b/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/concepts/JpaPdpPolicyStatusTest.java
new file mode 100644
index 000000000..fdadae768
--- /dev/null
+++ b/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/concepts/JpaPdpPolicyStatusTest.java
@@ -0,0 +1,196 @@
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.models.pdp.persistence.concepts;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+import org.assertj.core.api.AbstractStringAssert;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.models.base.PfKey;
+import org.onap.policy.models.base.PfReferenceKey;
+import org.onap.policy.models.base.Validated;
+import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
+import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
+import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
+
+public class JpaPdpPolicyStatusTest {
+    private static final String MY_PDP = "MyPdp";
+    private static final String MY_GROUP = "MyGroup";
+    private static final String MY_PDP_TYPE = "MyPdpType";
+    private static final ToscaConceptIdentifier POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3");
+    private static final ToscaConceptIdentifier POLICY_TYPE = new ToscaConceptIdentifier("MyPolicyType", "1.2.4");
+
+    private PdpPolicyStatusBuilder builder;
+
+
+    /**
+     * Set up Policy Status builder.
+     */
+    @Before
+    public void setup() {
+        // @formatter:off
+        builder = PdpPolicyStatus.builder()
+                        .deploy(true)
+                        .pdpGroup(MY_GROUP)
+                        .pdpId(MY_PDP)
+                        .pdpType(MY_PDP_TYPE)
+                        .policy(POLICY)
+                        .policyType(POLICY_TYPE)
+                        .state(State.SUCCESS);
+        // @formatter:on
+    }
+
+    @Test
+    public void testJpaPdpPolicyStatus() {
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus();
+
+        assertThat(jpa.getKey()).isNotNull();
+        assertThat(jpa.getKey().isNullKey()).isTrue();
+        assertThat(jpa.getPdpGroup()).isEqualTo(PfKey.NULL_KEY_NAME);
+        assertThat(jpa.getPdpType()).isEqualTo(PfKey.NULL_KEY_NAME);
+        assertThat(jpa.getPolicyType()).isNotNull();
+        assertThat(jpa.getPolicyType().isNullKey()).isTrue();
+        assertThat(jpa.isDeploy()).isFalse();
+        assertThat(jpa.getState()).isEqualTo(State.WAITING);
+    }
+
+    @Test
+    public void testJpaPdpPolicyStatusJpaPdpPolicyStatus() {
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
+
+        assertThat(new JpaPdpPolicyStatus(jpa)).isEqualTo(jpa);
+    }
+
+    @Test
+    public void testJpaPdpPolicyStatusPdpPolicyStatus() {
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
+
+        assertThat(jpa.getKey()).isNotNull();
+        PfReferenceKey key = jpa.getKey();
+        assertThat(key.getParentKeyName()).isEqualTo(POLICY.getName());
+        assertThat(key.getParentKeyVersion()).isEqualTo(POLICY.getVersion());
+        assertThat(key.getParentLocalName()).isEqualTo(PfKey.NULL_KEY_NAME);
+        assertThat(key.getLocalName()).isEqualTo(MY_PDP);
+
+        assertThat(jpa.getPdpGroup()).isEqualTo(MY_GROUP);
+        assertThat(jpa.getPdpType()).isEqualTo(MY_PDP_TYPE);
+
+        assertThat(jpa.getPolicyType()).isNotNull();
+        assertThat(jpa.getPolicyType().getName()).isEqualTo(POLICY_TYPE.getName());
+        assertThat(jpa.getPolicyType().getVersion()).isEqualTo(POLICY_TYPE.getVersion());
+
+        assertThat(jpa.isDeploy()).isTrue();
+        assertThat(jpa.getState()).isEqualTo(State.SUCCESS);
+    }
+
+    @Test
+    public void testGetKeys() {
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
+
+        assertThat(jpa.getKeys()).isEqualTo(List.of(jpa.getKey()));
+    }
+
+    @Test
+    public void testClean() {
+        JpaPdpPolicyStatus jpa =
+                        new JpaPdpPolicyStatus(builder.pdpGroup(MY_GROUP + " ").pdpType(MY_PDP_TYPE + " ").build());
+
+        jpa.clean();
+
+        assertThat(jpa.getPdpGroup()).isEqualTo(MY_GROUP);
+        assertThat(jpa.getPdpType()).isEqualTo(MY_PDP_TYPE);
+    }
+
+    @Test
+    @SuppressWarnings("serial")
+    public void testCompareTo() {
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
+
+        assertNotEquals(0, jpa.compareTo(null));
+        assertEquals(0, jpa.compareTo(jpa));
+        assertNotEquals(0, jpa.compareTo(new JpaPdpPolicyStatus(builder.build()) {}));
+
+        assertNotEquals(0, checkCompareTo(bldr -> bldr.pdpId("AnotherPdp")));
+        assertNotEquals(0, checkCompareTo(bldr -> bldr.pdpGroup("AnotherGroup")));
+        assertNotEquals(0, checkCompareTo(bldr -> bldr.pdpType("AnotherType")));
+        assertNotEquals(0, checkCompareTo(
+            bldr -> bldr.policyType(new ToscaConceptIdentifier("AnotherPolicyType", "1.2.4"))));
+        assertNotEquals(0, checkCompareTo(bldr -> bldr.deploy(false)));
+        assertNotEquals(0, checkCompareTo(bldr -> bldr.state(State.FAILURE)));
+    }
+
+    private int checkCompareTo(UnaryOperator<PdpPolicyStatusBuilder> fieldModifier) {
+        JpaPdpPolicyStatus jpa1 = new JpaPdpPolicyStatus(builder.build());
+        JpaPdpPolicyStatus jpa2 = new JpaPdpPolicyStatus(fieldModifier.apply(builder).build());
+
+        return jpa1.compareTo(jpa2);
+    }
+
+    @Test
+    public void testToAuthorative() {
+        PdpPolicyStatus data = builder.build();
+
+        assertThat(new JpaPdpPolicyStatus(data).toAuthorative()).isEqualTo(data);
+    }
+
+    @Test
+    public void testFromAuthorative() {
+        PdpPolicyStatus data = builder.build();
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus();
+
+        jpa.fromAuthorative(data);
+
+        assertThat(jpa).isEqualTo(new JpaPdpPolicyStatus(data));
+    }
+
+    @Test
+    public void testValidate() {
+        assertThat(new JpaPdpPolicyStatus(builder.build()).validate("").getResult()).isNull();
+
+        assertThatThrownBy(() -> new JpaPdpPolicyStatus(builder.build()).validate(null))
+                        .hasMessageContaining("fieldName").hasMessageContaining("is null");
+
+        checkValidate(jpa -> jpa.getKey().setParentKeyName(PfKey.NULL_KEY_NAME)).contains("policy name",
+                        Validated.IS_NULL);
+
+        checkValidate(jpa -> jpa.getKey().setParentKeyVersion(PfKey.NULL_KEY_VERSION)).contains("policy version",
+                        Validated.IS_NULL);
+
+        checkValidate(jpa -> jpa.getKey().setParentLocalName("SomeName")).contains("parent local name", "must be NULL");
+
+        checkValidate(jpa -> jpa.getKey().setLocalName(PfKey.NULL_KEY_NAME)).contains("pdpId", Validated.IS_NULL);
+    }
+
+    private AbstractStringAssert<?> checkValidate(Consumer<JpaPdpPolicyStatus> fieldModifier) {
+        JpaPdpPolicyStatus jpa = new JpaPdpPolicyStatus(builder.build());
+        fieldModifier.accept(jpa);
+
+        return assertThat(jpa.validate("").getResult());
+    }
+}
diff --git a/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/provider/PdpProviderTest.java b/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/provider/PdpProviderTest.java
index d57204adf..2bf942a6a 100644
--- a/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/provider/PdpProviderTest.java
+++ b/models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/provider/PdpProviderTest.java
@@ -1,7 +1,7 @@
 /*-
  * ============LICENSE_START=======================================================
  *  Copyright (C) 2019-2021 Nordix Foundation.
- *  Modifications Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
+ *  Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
  * ================================================================================
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,12 +21,15 @@
 
 package org.onap.policy.models.pdp.persistence.provider;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertTrue;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Properties;
 import org.eclipse.persistence.config.PersistenceUnitProperties;
@@ -36,6 +39,7 @@ import org.junit.Test;
 import org.onap.policy.common.utils.coder.StandardCoder;
 import org.onap.policy.common.utils.resources.ResourceUtils;
 import org.onap.policy.models.base.PfModelException;
+import org.onap.policy.models.base.PfModelRuntimeException;
 import org.onap.policy.models.base.Validated;
 import org.onap.policy.models.dao.DaoParameters;
 import org.onap.policy.models.dao.PfDao;
@@ -45,6 +49,9 @@ import org.onap.policy.models.pdp.concepts.Pdp;
 import org.onap.policy.models.pdp.concepts.PdpGroup;
 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
 import org.onap.policy.models.pdp.concepts.PdpGroups;
+import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
+import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
+import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
 import org.onap.policy.models.pdp.concepts.PdpStatistics;
 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
@@ -64,8 +71,11 @@ public class PdpProviderTest {
     private static final String GROUP_IS_NULL = "pdpGroupName is marked .*ull but is null";
     private static final String DAO_IS_NULL = "dao is marked .*ull but is null";
     private static final String PDP_GROUP0 = "PdpGroup0";
+    private static final String GROUP_A = "groupA";
+    private static final String GROUP_B = "groupB";
     private PfDao pfDao;
     private StandardCoder standardCoder;
+    private PdpPolicyStatusBuilder statusBuilder;
 
 
     /**
@@ -102,6 +112,18 @@ public class PdpProviderTest {
         standardCoder = new StandardCoder();
     }
 
+    /**
+     * Set up Policy Status builder.
+     */
+    @Before
+    public void setupBuilder() {
+        ToscaConceptIdentifier policy = new ToscaConceptIdentifier("MyPolicy", "1.2.3");
+        ToscaConceptIdentifier policyType = new ToscaConceptIdentifier("MyPolicyType", "1.2.4");
+
+        statusBuilder = PdpPolicyStatus.builder().deploy(true).pdpType("MyPdpType").policy(policy)
+                        .policyType(policyType).state(State.SUCCESS);
+    }
+
     @After
     public void teardown() {
         pfDao.close();
@@ -621,4 +643,130 @@ public class PdpProviderTest {
 
         new PdpProvider().updatePdpStatistics(pfDao, "name", "TYPE", "inst", new PdpStatistics());
     }
+
+    @Test
+    public void testGetGroupPolicyStatus() throws PfModelException {
+        assertThatThrownBy(() -> {
+            new PdpProvider().getGroupPolicyStatus(null, "someGroup");
+        }).hasMessageMatching(DAO_IS_NULL);
+
+        assertThatThrownBy(() -> {
+            new PdpProvider().getGroupPolicyStatus(pfDao, null);
+        }).hasMessageContaining("group").hasMessageContaining("null");
+
+        assertThat(new PdpProvider().getGroupPolicyStatus(pfDao, PDP_GROUP0)).isEmpty();
+    }
+
+    @Test
+    public void cudPolicyStatus() throws PfModelException {
+        PdpProvider prov = new PdpProvider();
+
+        assertThatThrownBy(() -> prov.cudPolicyStatus(null, List.of(), List.of(), List.of()))
+                        .hasMessageMatching(DAO_IS_NULL);
+
+        // null collections should be OK
+        assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
+    }
+
+    @Test
+    public void cudPolicyStatus_Create() throws PfModelException {
+        PdpProvider prov = new PdpProvider();
+
+        PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
+        PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
+        PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_B).pdpId("idZ").build();
+        prov.cudPolicyStatus(pfDao, List.of(idx, idy), null, null);
+        prov.cudPolicyStatus(pfDao, List.of(idz), null, null);
+
+        List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
+        assertThat(records).hasSize(2);
+
+        Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
+        assertThat(records.get(0)).isEqualTo(idx);
+        assertThat(records.get(1)).isEqualTo(idy);
+
+        records = prov.getGroupPolicyStatus(pfDao, GROUP_B);
+        assertThat(records).hasSize(1);
+        assertThat(records.get(0)).isEqualTo(idz);
+    }
+
+    @Test
+    public void cudPolicyStatus_Update() throws PfModelException {
+        PdpProvider prov = new PdpProvider();
+
+        PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("wId").build();
+        PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("xId").build();
+        PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("yId").build();
+        PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("zId").build();
+        prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
+
+        assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
+
+        /*
+         * Now update some records.
+         */
+        idx.setState(State.FAILURE);
+        idz.setState(State.WAITING);
+        prov.cudPolicyStatus(pfDao, null, List.of(idx, idz), null);
+        List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
+        assertThat(records).hasSize(4);
+
+        Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
+        assertThat(records.get(0)).isEqualTo(idw);
+        assertThat(records.get(1)).isEqualTo(idx);
+        assertThat(records.get(2)).isEqualTo(idy);
+        assertThat(records.get(3)).isEqualTo(idz);
+    }
+
+    @Test
+    public void cudPolicyStatus_Delete() throws PfModelException {
+        PdpProvider prov = new PdpProvider();
+
+        PdpPolicyStatus idw = statusBuilder.pdpGroup(GROUP_A).pdpId("idW").build();
+        PdpPolicyStatus idx = statusBuilder.pdpGroup(GROUP_A).pdpId("idX").build();
+        PdpPolicyStatus idy = statusBuilder.pdpGroup(GROUP_A).pdpId("idY").build();
+        PdpPolicyStatus idz = statusBuilder.pdpGroup(GROUP_A).pdpId("idZ").build();
+        prov.cudPolicyStatus(pfDao, List.of(idw, idx, idy, idz), null, null);
+
+        assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).hasSize(4);
+
+        /*
+         * Delete some records and then check again.
+         */
+        prov.cudPolicyStatus(pfDao, null, null, List.of(idw, idy));
+
+        List<PdpPolicyStatus> records = prov.getGroupPolicyStatus(pfDao, GROUP_A);
+        assertThat(records).hasSize(2);
+
+        Collections.sort(records, (rec1, rec2) -> rec1.getPdpId().compareTo(rec2.getPdpId()));
+        assertThat(records.get(0)).isEqualTo(idx);
+        assertThat(records.get(1)).isEqualTo(idz);
+    }
+
+    @Test
+    public void testFromAuthorativeStatus() throws PfModelException {
+        PdpProvider prov = new PdpProvider();
+
+        assertThatCode(() -> prov.cudPolicyStatus(pfDao, null, null, null)).doesNotThrowAnyException();
+
+        PdpPolicyStatus ida = statusBuilder.pdpGroup(GROUP_A).pdpId("idA").build();
+        PdpPolicyStatus idb = statusBuilder.pdpGroup(GROUP_A).pdpId("idB").build();
+        PdpPolicyStatus idc = statusBuilder.pdpGroup(GROUP_A).pdpId("idC").build();
+        PdpPolicyStatus idd = statusBuilder.pdpGroup(GROUP_A).pdpId("idD").build();
+
+        // make a couple invalid records
+        idb.setState(null);
+        idd.setState(null);
+
+        List<PdpPolicyStatus> list = List.of(ida, idb, idc, idd);
+
+        // @formatter:off
+        assertThatCode(() -> prov.cudPolicyStatus(pfDao, list, null, null))
+            .isInstanceOf(PfModelRuntimeException.class)
+            .hasMessageContaining("1").hasMessageContaining("3")
+            .hasMessageNotContaining("0").hasMessageNotContaining("2");
+        // @formatter:on
+
+        assertThat(prov.getGroupPolicyStatus(pfDao, GROUP_A)).isEmpty();
+    }
 }