Add class to manage policy deployment records

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

1 files changed, 529 insertions, 0 deletions

diff --git a/main/src/test/java/org/onap/policy/pap/main/notification/DeploymentStatusTest.java b/main/src/test/java/org/onap/policy/pap/main/notification/DeploymentStatusTest.java
new file mode 100644
index 00000000..e191e02b
--- /dev/null
+++ b/main/src/test/java/org/onap/policy/pap/main/notification/DeploymentStatusTest.java
@@ -0,0 +1,529 @@
+/*-
+ * ============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.pap.main.notification;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import lombok.NonNull;
+import org.apache.commons.lang3.builder.CompareToBuilder;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.onap.policy.models.base.PfModelException;
+import org.onap.policy.models.pap.concepts.PolicyNotification;
+import org.onap.policy.models.pap.concepts.PolicyStatus;
+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.provider.PolicyModelsProvider;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
+import org.onap.policy.pap.main.notification.StatusAction.Action;
+
+public class DeploymentStatusTest {
+
+    private static final String VERSION = "1.2.3";
+    private static final @NonNull String GROUP_A = "groupA";
+    private static final String PDP_A = "pdpA";
+    private static final String PDP_B = "pdpB";
+    private static final String PDP_C = "pdpC";
+    private static final String PDP_D = "pdpD";
+    private static final String PDP_TYPE = "MyPdpType";
+    private static final ToscaConceptIdentifier POLICY_A = new ToscaConceptIdentifier("MyPolicyA", VERSION);
+    private static final ToscaConceptIdentifier POLICY_B = new ToscaConceptIdentifier("MyPolicyB", VERSION);
+    private static final ToscaConceptIdentifier POLICY_C = new ToscaConceptIdentifier("MyPolicyC", VERSION);
+    private static final ToscaConceptIdentifier POLICY_D = new ToscaConceptIdentifier("MyPolicyD", VERSION);
+    private static final ToscaConceptIdentifier POLICY_TYPE = new ToscaConceptIdentifier("MyPolicyType", VERSION);
+
+    private PdpPolicyStatusBuilder builder;
+
+    @Captor
+    private ArgumentCaptor<List<PdpPolicyStatus>> created;
+    @Captor
+    private ArgumentCaptor<List<PdpPolicyStatus>> updated;
+    @Captor
+    private ArgumentCaptor<List<PdpPolicyStatus>> deleted;
+
+    @Mock
+    private PolicyModelsProvider provider;
+
+    private DeploymentStatus tracker;
+
+    /**
+     * Sets up.
+     */
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        tracker = new DeploymentStatus(provider);
+
+        // @formatter:off
+        builder = PdpPolicyStatus.builder()
+                        .pdpGroup(GROUP_A)
+                        .pdpId(PDP_A)
+                        .pdpType(PDP_TYPE)
+                        .policy(POLICY_A)
+                        .policyType(POLICY_TYPE)
+                        .deploy(true)
+                        .state(State.SUCCESS);
+        // @formatter:on
+    }
+
+    @Test
+    public void testAddNotifications() {
+        PdpPolicyStatus create = builder.pdpId("created").state(State.FAILURE).build();
+        PdpPolicyStatus update = builder.pdpId("updated").state(State.SUCCESS).build();
+        PdpPolicyStatus delete = builder.pdpId("deleted").state(State.SUCCESS).build();
+        PdpPolicyStatus unchange = builder.pdpId("unchanged").state(State.FAILURE).build();
+
+        // @formatter:off
+        tracker.getRecordMap().putAll(makeMap(
+                        Action.CREATED, create,
+                        Action.UPDATED, update,
+                        Action.DELETED, delete,
+                        Action.UNCHANGED, unchange
+                        ));
+        // @formatter:on
+
+        PolicyNotification notif = new PolicyNotification();
+
+        tracker.addNotifications(notif);
+        assertThat(notif.getAdded()).hasSize(1);
+        assertThat(notif.getDeleted()).isEmpty();
+
+        PolicyStatus status = notif.getAdded().get(0);
+        assertThat(status.getFailureCount()).isEqualTo(2);
+        assertThat(status.getIncompleteCount()).isZero();
+        assertThat(status.getSuccessCount()).isEqualTo(1);
+        assertThat(status.getPolicy()).isEqualTo(POLICY_A);
+        assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
+
+        /*
+         * repeat - should be no notifications
+         */
+        notif = new PolicyNotification();
+        tracker.addNotifications(notif);
+        assertThat(notif.getAdded()).isEmpty();
+        assertThat(notif.getDeleted()).isEmpty();
+    }
+
+    @Test
+    public void testLoadByGroup() throws PfModelException {
+        PdpPolicyStatus status1 = builder.build();
+        PdpPolicyStatus status2 = builder.policy(POLICY_B).build();
+        PdpPolicyStatus status3 = builder.policy(POLICY_A).pdpId(PDP_B).build();
+
+        when(provider.getGroupPolicyStatus(GROUP_A)).thenReturn(List.of(status1, status2, status3));
+
+        tracker.loadByGroup(GROUP_A);
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+            Action.UNCHANGED, status1,
+            Action.UNCHANGED, status2,
+            Action.UNCHANGED, status3
+            ));
+        // @formatter:on
+
+        // try again - should not reload
+        tracker.loadByGroup(GROUP_A);
+        verify(provider).getGroupPolicyStatus(anyString());
+    }
+
+    @Test
+    public void testFlushPdpNotification() {
+        PdpPolicyStatus create = builder.pdpId("created").state(State.FAILURE).build();
+        tracker.getRecordMap().putAll(makeMap(Action.CREATED, create));
+
+        PolicyNotification notif = new PolicyNotification();
+
+        tracker.flush(notif);
+
+        assertThat(notif.getAdded()).hasSize(1);
+        assertThat(notif.getDeleted()).isEmpty();
+    }
+
+    @Test
+    public void testFlush() throws PfModelException {
+        PdpPolicyStatus create1 = builder.pdpId("createA").build();
+        PdpPolicyStatus create2 = builder.pdpId("createB").build();
+        PdpPolicyStatus update1 = builder.pdpId("updateA").build();
+        PdpPolicyStatus update2 = builder.pdpId("updateB").build();
+        PdpPolicyStatus delete1 = builder.pdpId("deleteA").build();
+        PdpPolicyStatus delete2 = builder.pdpId("deleteB").build();
+        PdpPolicyStatus unchange1 = builder.pdpId("unchangeA").build();
+        PdpPolicyStatus unchange2 = builder.pdpId("unchangeB").build();
+
+        // @formatter:off
+        tracker.getRecordMap().putAll(makeMap(
+                        Action.CREATED, create1,
+                        Action.CREATED, create2,
+                        Action.UPDATED, update1,
+                        Action.UPDATED, update2,
+                        Action.DELETED, delete1,
+                        Action.DELETED, delete2,
+                        Action.UNCHANGED, unchange1,
+                        Action.UNCHANGED, unchange2
+                        ));
+        // @formatter:on
+
+        tracker.flush();
+
+        verify(provider).cudPolicyStatus(created.capture(), updated.capture(), deleted.capture());
+
+        assertThat(sort(created.getValue())).isEqualTo(List.of(create1, create2));
+        assertThat(sort(updated.getValue())).isEqualTo(List.of(update1, update2));
+        assertThat(sort(deleted.getValue())).isEqualTo(List.of(delete1, delete2));
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+                        Action.UNCHANGED, create1,
+                        Action.UNCHANGED, create2,
+                        Action.UNCHANGED, update1,
+                        Action.UNCHANGED, update2,
+                        Action.UNCHANGED, unchange1,
+                        Action.UNCHANGED, unchange2
+                        ));
+        // @formatter:on
+    }
+
+    @Test
+    public void testDeleteUndeployments() {
+        builder.deploy(true);
+        PdpPolicyStatus delete = builder.policy(POLICY_A).build();
+        PdpPolicyStatus deployedComplete = builder.policy(POLICY_B).build();
+
+        builder.deploy(false);
+        PdpPolicyStatus undepComplete1 = builder.policy(POLICY_C).build();
+        PdpPolicyStatus undepIncomplete1 = builder.policy(POLICY_D).build();
+
+        builder.pdpId(PDP_B);
+        PdpPolicyStatus undepComplete2 = builder.policy(POLICY_C).build();
+        PdpPolicyStatus undepIncomplete2 = builder.policy(POLICY_D).state(State.WAITING).build();
+
+        // @formatter:off
+        Map<StatusKey, StatusAction> map = makeMap(
+                        Action.DELETED, delete,
+                        Action.UNCHANGED, deployedComplete,
+                        Action.UNCHANGED, undepComplete1,
+                        Action.UNCHANGED, undepComplete2,
+                        Action.UNCHANGED, undepIncomplete1,
+                        Action.UNCHANGED, undepIncomplete2
+                        );
+        // @formatter:on
+
+        tracker.getRecordMap().putAll(map);
+
+        tracker.deleteUndeployments();
+
+        // the completed undeployments should now be marked DELETED
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+                        Action.DELETED, delete,
+                        Action.UNCHANGED, deployedComplete,
+                        Action.DELETED, undepComplete1,
+                        Action.DELETED, undepComplete2,
+                        Action.UNCHANGED, undepIncomplete1,
+                        Action.UNCHANGED, undepIncomplete2
+                        ));
+        // @formatter:on
+    }
+
+    @Test
+    public void testDeleteDeploymentString() {
+        PdpPolicyStatus statusaa = builder.pdpId(PDP_A).policy(POLICY_A).build();
+        PdpPolicyStatus statusab = builder.pdpId(PDP_A).policy(POLICY_B).build();
+        PdpPolicyStatus statusba = builder.pdpId(PDP_B).policy(POLICY_A).build();
+        PdpPolicyStatus statuscb = builder.pdpId(PDP_C).policy(POLICY_B).build();
+
+        // @formatter:off
+        tracker.getRecordMap().putAll(makeMap(
+                        Action.UNCHANGED, statusaa,
+                        Action.UNCHANGED, statusab,
+                        Action.UNCHANGED, statusba,
+                        Action.UNCHANGED, statuscb
+                        ));
+        // @formatter:on
+
+        tracker.deleteDeployment(PDP_A);
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+                        Action.DELETED, statusaa,
+                        Action.DELETED, statusab,
+                        Action.UNCHANGED, statusba,
+                        Action.UNCHANGED, statuscb
+                        ));
+        // @formatter:on
+    }
+
+    @Test
+    public void testDeleteDeploymentToscaConceptIdentifierBoolean() {
+        PdpPolicyStatus deploy1A = builder.policy(POLICY_A).build();
+        PdpPolicyStatus deploy2A = builder.policy(POLICY_A).pdpId(PDP_B).build();
+        PdpPolicyStatus deployB = builder.policy(POLICY_B).pdpId(PDP_A).build();
+
+        builder.deploy(false);
+        PdpPolicyStatus undeployA = builder.policy(POLICY_A).build();
+        PdpPolicyStatus undeployB = builder.policy(POLICY_B).build();
+
+        // @formatter:off
+        tracker.getRecordMap().putAll(makeMap(
+                        Action.UNCHANGED, deploy1A,
+                        Action.UNCHANGED, deploy2A,
+                        Action.UNCHANGED, deployB,
+                        Action.UNCHANGED, undeployA,
+                        Action.UNCHANGED, undeployB
+                        ));
+        // @formatter:on
+
+        tracker.deleteDeployment(POLICY_A, true);
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+                        Action.DELETED, deploy1A,
+                        Action.DELETED, deploy2A,
+                        Action.UNCHANGED, deployB,
+                        Action.UNCHANGED, undeployA,
+                        Action.UNCHANGED, undeployB
+                        ));
+        // @formatter:on
+
+        tracker.deleteDeployment(POLICY_B, false);
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+                        Action.DELETED, deploy1A,
+                        Action.DELETED, deploy2A,
+                        Action.UNCHANGED, deployB,
+                        Action.UNCHANGED, undeployA,
+                        Action.DELETED, undeployB
+                        ));
+        // @formatter:on
+    }
+
+    @Test
+    public void testDeleteDeploymentBiPredicateOfStatusKeyStatusAction() {
+        PdpPolicyStatus create1 = builder.pdpId(PDP_A).build();
+        PdpPolicyStatus delete = builder.pdpId(PDP_B).build();
+        PdpPolicyStatus update = builder.pdpId(PDP_C).build();
+        PdpPolicyStatus unchange = builder.pdpId(PDP_D).build();
+
+        PdpPolicyStatus create2 = builder.pdpId(PDP_B).build();
+
+        // @formatter:off
+        tracker.getRecordMap().putAll(makeMap(
+                        Action.CREATED, create1,
+                        Action.CREATED, create2,
+                        Action.DELETED, delete,
+                        Action.UPDATED, update,
+                        Action.UNCHANGED, unchange
+                        ));
+        // @formatter:on
+
+        tracker.deleteDeployment(POLICY_A, true);
+
+        // @formatter:off
+        assertThat(tracker.getRecordMap()).isEqualTo(makeMap(
+                        Action.DELETED, delete,
+                        Action.DELETED, update,
+                        Action.DELETED, unchange
+                        ));
+        // @formatter:on
+    }
+
+    @Test
+    public void testDeploy() {
+        tracker.deploy(PDP_A, POLICY_A, POLICY_TYPE, GROUP_A, PDP_TYPE, true);
+
+        assertThat(tracker.getRecordMap()).hasSize(1);
+
+        StatusAction status2 = tracker.getRecordMap().values().iterator().next();
+
+        assertThat(status2.getAction()).isEqualTo(Action.CREATED);
+        assertThat(status2.getStatus().getState()).isEqualTo(State.WAITING);
+        assertThat(status2.getStatus().isDeploy()).isTrue();
+
+        /*
+         * repeat - should be the same status
+         */
+        tracker.deploy(PDP_A, POLICY_A, POLICY_TYPE, GROUP_A, PDP_TYPE, true);
+
+        assertThat(tracker.getRecordMap()).hasSize(1);
+        assertThat(tracker.getRecordMap().values().iterator().next()).isSameAs(status2);
+        assertThat(status2.getAction()).isEqualTo(Action.CREATED);
+        assertThat(status2.getStatus().getState()).isEqualTo(State.WAITING);
+        assertThat(status2.getStatus().isDeploy()).isTrue();
+
+        /*
+         * repeat, with different values - should be unchanged
+         */
+        status2.setAction(Action.UNCHANGED);
+        status2.getStatus().setDeploy(true);
+        status2.getStatus().setState(State.SUCCESS);
+
+        tracker.deploy(PDP_A, POLICY_A, POLICY_TYPE, GROUP_A, PDP_TYPE, true);
+
+        assertThat(tracker.getRecordMap()).hasSize(1);
+        assertThat(tracker.getRecordMap().values().iterator().next()).isSameAs(status2);
+        assertThat(status2.getAction()).isEqualTo(Action.UNCHANGED);
+        assertThat(status2.getStatus().getState()).isEqualTo(State.SUCCESS);
+        assertThat(status2.getStatus().isDeploy()).isTrue();
+
+        /*
+         * incorrect "deploy" value - should update it
+         */
+        status2.setAction(Action.UNCHANGED);
+        status2.getStatus().setDeploy(true);
+
+        tracker.deploy(PDP_A, POLICY_A, POLICY_TYPE, GROUP_A, PDP_TYPE, false);
+
+        assertThat(status2.getAction()).isEqualTo(Action.UPDATED);
+        assertThat(status2.getStatus().getState()).isEqualTo(State.WAITING);
+        assertThat(status2.getStatus().isDeploy()).isFalse();
+
+        /*
+         * marked for deletion - should reinstate it
+         */
+        status2.setAction(Action.DELETED);
+        status2.getStatus().setState(State.FAILURE);
+        status2.getStatus().setDeploy(false);
+
+        tracker.deploy(PDP_A, POLICY_A, POLICY_TYPE, GROUP_A, PDP_TYPE, false);
+
+        assertThat(status2.getAction()).isEqualTo(Action.UPDATED);
+        assertThat(status2.getStatus().getState()).isEqualTo(State.FAILURE);
+        assertThat(status2.getStatus().isDeploy()).isFalse();
+    }
+
+    @Test
+    public void testCompleteDeploy() {
+        tracker.deploy(PDP_A, POLICY_A, POLICY_TYPE, GROUP_A, PDP_TYPE, true);
+        assertThat(tracker.getRecordMap()).hasSize(1);
+
+        // deployed, but not expected to be deployed - record should be left as is
+        checkCompleteDeploy(true, Set.of(), Set.of(), Action.UNCHANGED, State.WAITING);
+        checkCompleteDeploy(true, Set.of(), Set.of(POLICY_A), Action.UNCHANGED, State.WAITING);
+
+        // expected, but not actually deployed - failure
+        checkCompleteDeploy(true, Set.of(POLICY_A), Set.of(), Action.UPDATED, State.FAILURE);
+
+        // expected and actually deployed - success
+        checkCompleteDeploy(true, Set.of(POLICY_A), Set.of(POLICY_A), Action.UPDATED, State.SUCCESS);
+        checkCompleteDeploy(true, Set.of(POLICY_A, POLICY_B), Set.of(POLICY_A), Action.UPDATED, State.SUCCESS);
+
+        // not expected and not actually deployed - success
+        checkCompleteDeploy(false, Set.of(), Set.of(), Action.UPDATED, State.SUCCESS);
+
+        // not expected, but actually deployed - failure
+        checkCompleteDeploy(false, Set.of(), Set.of(POLICY_A), Action.UPDATED, State.FAILURE);
+
+        // undeployed, but expected to be deployed - record should be left as is
+        checkCompleteDeploy(false, Set.of(POLICY_A), Set.of(), Action.UNCHANGED, State.WAITING);
+        checkCompleteDeploy(false, Set.of(POLICY_A), Set.of(POLICY_A), Action.UNCHANGED, State.WAITING);
+        checkCompleteDeploy(false, Set.of(POLICY_A, POLICY_B), Set.of(POLICY_A), Action.UNCHANGED, State.WAITING);
+
+        /*
+         * Try a case where the state is already correct.
+         */
+        StatusAction status = tracker.getRecordMap().values().iterator().next();
+        status.getStatus().setDeploy(false);
+        status.setAction(Action.UNCHANGED);
+        status.getStatus().setState(State.SUCCESS);
+
+        tracker.completeDeploy(PDP_A, Set.of(), Set.of());
+
+        assertThat(status.getAction()).isEqualTo(Action.UNCHANGED);
+        assertThat(status.getStatus().getState()).isEqualTo(State.SUCCESS);
+
+        /*
+         * Try a case where the PDP does not match the record.
+         */
+        status.getStatus().setDeploy(false);
+        status.setAction(Action.UNCHANGED);
+        status.getStatus().setState(State.WAITING);
+
+        tracker.completeDeploy(PDP_B, Set.of(), Set.of());
+
+        assertThat(status.getAction()).isEqualTo(Action.UNCHANGED);
+        assertThat(status.getStatus().getState()).isEqualTo(State.WAITING);
+    }
+
+    private void checkCompleteDeploy(boolean deploy, Set<ToscaConceptIdentifier> expected,
+                    Set<ToscaConceptIdentifier> actual, Action action, State state) {
+
+        StatusAction status = tracker.getRecordMap().values().iterator().next();
+        status.getStatus().setDeploy(deploy);
+        status.setAction(Action.UNCHANGED);
+        status.getStatus().setState(State.WAITING);
+
+        tracker.completeDeploy(PDP_A, expected, actual);
+
+        assertThat(status.getAction()).isEqualTo(action);
+        assertThat(status.getStatus().getState()).isEqualTo(state);
+    }
+
+    private List<PdpPolicyStatus> sort(List<PdpPolicyStatus> list) {
+
+        Collections.sort(list, (rec1, rec2) -> {
+
+            // @formatter:off
+            return new CompareToBuilder()
+                            .append(rec1.getPdpId(), rec2.getPdpId())
+                            .append(rec1.getPolicy(), rec2.getPolicy())
+                            .toComparison();
+            // @formatter:on
+        });
+
+        return list;
+    }
+
+    /**
+     * Makes a map.
+     *
+     * @param data pairs of (Action, PdpPolicyStatus)
+     * @return a new map containing the given data
+     */
+    private Map<StatusKey, StatusAction> makeMap(Object... data) {
+        Map<StatusKey, StatusAction> map = new HashMap<>();
+
+        assert (data.length % 2 == 0);
+
+        for (int idata = 0; idata < data.length; idata += 2) {
+            Action action = (Action) data[idata];
+            PdpPolicyStatus status = (PdpPolicyStatus) data[idata + 1];
+            map.put(new StatusKey(status), new StatusAction(action, status));
+        }
+
+        return map;
+    }
+}