main/src/test/java/org/onap/policy/pap/main/rest/TestPolicyStatusProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2021-2022 Bell Canada. All rights reserved.
   7  * Modifications Copyright (C) 2021 Nordix Foundation.
   8  * ================================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.pap.main.rest;
  24
  25 import static org.assertj.core.api.Assertions.assertThat;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.mockito.Mockito.when;
  29
  30 import java.util.ArrayList;
  31 import java.util.Collection;
  32 import java.util.Collections;
  33 import java.util.Iterator;
  34 import java.util.List;
  35 import lombok.NonNull;
  36 import org.junit.AfterClass;
  37 import org.junit.Before;
  38 import org.junit.Test;
  39 import org.onap.policy.common.utils.services.Registry;
  40 import org.onap.policy.models.base.PfModelException;
  41 import org.onap.policy.models.pap.concepts.PolicyStatus;
  42 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  43 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
  44 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
  45 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  46 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
  47
  48 public class TestPolicyStatusProvider extends ProviderSuper {
  49     private static final String MY_GROUP = "MyGroup";
  50     private static final String MY_PDP_TYPE = "MySubGroup";
  51     private static final @NonNull String VERSION = "1.2.3";
  52     private static final String PDP_A = "pdpA";
  53     private static final String PDP_B = "pdpB";
  54     private static final String PDP_C = "pdpC";
  55     private static final ToscaConceptIdentifier POLICY_TYPE = new ToscaConceptIdentifier("MyPolicyType", VERSION);
  56     private static final ToscaConceptIdentifier POLICY_A = new ToscaConceptIdentifier("MyPolicyA", VERSION);
  57     private static final ToscaConceptIdentifier POLICY_B = new ToscaConceptIdentifier("MyPolicyB", VERSION);
  58     private static final ToscaConceptIdentifier POLICY_C = new ToscaConceptIdentifier("MyPolicyC", VERSION);
  59
  60     private PolicyStatusProvider prov;
  61
  62     @AfterClass
  63     public static void tearDownAfterClass() {
  64         Registry.newRegistry();
  65     }
  66
  67     /**
  68      * Configures mocks and objects.
  69      *
  70      * @throws Exception if an error occurs
  71      */
  72     @Override
  73     @Before
  74     public void setUp() throws Exception {
  75
  76         super.setUp();
  77
  78         prov = new PolicyStatusProvider(policyStatusService);
  79     }
  80
  81     @Test
  82     public void testGetStatus_testAccumulate() throws PfModelException {
  83
  84         buildPolicyStatusToReturn1();
  85
  86         List<PolicyStatus> result = new ArrayList<>(prov.getStatus());
  87         Collections.sort(result, (rec1, rec2) -> rec1.getPolicy().compareTo(rec2.getPolicy()));
  88
  89         assertThat(result).hasSize(3);
  90
  91         Iterator<PolicyStatus> iter = result.iterator();
  92
  93         PolicyStatus status = iter.next();
  94         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
  95         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
  96         assertThat(status.getIncompleteCount()).isEqualTo(2);
  97         assertThat(status.getFailureCount()).isZero();
  98         assertThat(status.getSuccessCount()).isZero();
  99
 100         status = iter.next();
 101         assertThat(status.getPolicy()).isEqualTo(POLICY_B);
 102         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 103         assertThat(status.getIncompleteCount()).isZero();
 104         assertThat(status.getFailureCount()).isZero();
 105         assertThat(status.getSuccessCount()).isEqualTo(1);
 106
 107         status = iter.next();
 108         assertThat(status.getPolicy()).isEqualTo(POLICY_C);
 109         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 110         assertThat(status.getIncompleteCount()).isEqualTo(1);
 111         assertThat(status.getFailureCount()).isZero();
 112         assertThat(status.getSuccessCount()).isZero();
 113     }
 114
 115     @Test
 116     public void testGetStatusToscaConceptIdentifierOptVersion() throws PfModelException {
 117
 118         ToscaConceptIdentifierOptVersion optIdent = buildPolicyStatusToReturn2();
 119
 120         List<PolicyStatus> result = new ArrayList<>(prov.getStatus(optIdent));
 121         assertThat(result).hasSize(1);
 122
 123         Iterator<PolicyStatus> iter = result.iterator();
 124
 125         PolicyStatus status = iter.next();
 126         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 127         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 128         assertThat(status.getIncompleteCount()).isEqualTo(2);
 129         assertThat(status.getFailureCount()).isZero();
 130         assertThat(status.getSuccessCount()).isZero();
 131     }
 132
 133     @Test
 134     public void testGetPolicyStatus() throws PfModelException {
 135
 136         buildPolicyStatusToReturn1();
 137
 138         List<PdpPolicyStatus> result = new ArrayList<>(prov.getPolicyStatus());
 139         Collections.sort(result, (rec1, rec2) -> rec1.getPolicy().compareTo(rec2.getPolicy()));
 140
 141         assertThat(result).hasSize(5);
 142         Iterator<PdpPolicyStatus> iter = result.iterator();
 143
 144         PdpPolicyStatus status = iter.next();
 145         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 146         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 147         assertThat(status.getPdpId()).isEqualTo(PDP_A);
 148         assertThat(status.getPdpType()).isEqualTo(MY_PDP_TYPE);
 149         assertThat(status.getPdpGroup()).isEqualTo(MY_GROUP);
 150         assertTrue(status.isDeploy());
 151         assertThat(status.getState()).isEqualTo(State.WAITING);
 152
 153         status = iter.next();
 154         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 155         assertThat(status.getPdpId()).isEqualTo(PDP_B);
 156         assertTrue(status.isDeploy());
 157         assertThat(status.getState()).isEqualTo(State.WAITING);
 158
 159         status = iter.next();
 160         assertThat(status.getPolicy()).isEqualTo(POLICY_B);
 161         assertThat(status.getPdpId()).isEqualTo(PDP_A);
 162         assertFalse(status.isDeploy());
 163         assertThat(status.getState()).isEqualTo(State.WAITING);
 164
 165         status = iter.next();
 166         assertThat(status.getPolicy()).isEqualTo(POLICY_B);
 167         assertThat(status.getPdpId()).isEqualTo(PDP_B);
 168         assertTrue(status.isDeploy());
 169         assertThat(status.getState()).isEqualTo(State.SUCCESS);
 170     }
 171
 172     @Test
 173     public void testGetPolicyStatusByGroupAndPolicyIdVersion() throws PfModelException {
 174
 175         ToscaConceptIdentifierOptVersion optIdent = buildPolicyStatusToReturn2();
 176
 177         List<PdpPolicyStatus> result = new ArrayList<>(prov.getPolicyStatus(MY_GROUP, optIdent));
 178         assertThat(result).hasSize(3);
 179
 180         Iterator<PdpPolicyStatus> iter = result.iterator();
 181
 182         PdpPolicyStatus status = iter.next();
 183         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 184         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 185         assertThat(status.getPdpId()).isEqualTo(PDP_A);
 186         assertThat(status.getPdpType()).isEqualTo(MY_PDP_TYPE);
 187         assertThat(status.getPdpGroup()).isEqualTo(MY_GROUP);
 188         assertTrue(status.isDeploy());
 189         assertThat(status.getState()).isEqualTo(State.WAITING);
 190
 191         status = iter.next();
 192         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 193         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 194         assertThat(status.getPdpId()).isEqualTo(PDP_B);
 195         assertThat(status.getPdpType()).isEqualTo(MY_PDP_TYPE);
 196         assertThat(status.getPdpGroup()).isEqualTo(MY_GROUP);
 197         assertFalse(status.isDeploy());
 198         assertThat(status.getState()).isEqualTo(State.FAILURE);
 199     }
 200
 201     @Test
 202     public void testGetPolicyStatusByRegexNoMatch() throws PfModelException {
 203         buildPolicyStatusToReturn1();
 204         final String pattern = "Hello";
 205
 206         final Collection<PolicyStatus> actual = prov.getByRegex(pattern);
 207         assertThat(actual).isEmpty();
 208     }
 209
 210     @Test
 211     public void testGetPolicyStatusOneMatch() throws PfModelException {
 212         buildPolicyStatusToReturn1();
 213         final String pattern = "My(We|Po)[li]{0,3}c.A";
 214
 215         final Collection<PolicyStatus> actual = prov.getByRegex(pattern);
 216         assertThat(actual).hasSize(1);
 217
 218         final String actualName = actual.iterator().next().getPolicy().getName();
 219         assertThat(actualName).isEqualTo("MyPolicyA");
 220     }
 221
 222     @Test
 223     public void testGetPolicyStatusAllMatch() throws PfModelException {
 224         buildPolicyStatusToReturn1();
 225         final String pattern = "My(We|Po)[li]{0,3}c.{2}0*";
 226
 227         final Collection<PolicyStatus> actual = prov.getByRegex(pattern);
 228
 229         assertThat(actual).hasSize(3);
 230     }
 231
 232     private void buildPolicyStatusToReturn1() throws PfModelException {
 233
 234         PdpPolicyStatusBuilder builder = PdpPolicyStatus.builder().pdpGroup(MY_GROUP).pdpType(MY_PDP_TYPE)
 235             .policyType(POLICY_TYPE).state(State.WAITING);
 236
 237         PdpPolicyStatus notDeployed = builder.deploy(false).policy(POLICY_B).pdpId(PDP_A).build();
 238
 239         // remaining policies are deployed
 240         builder.deploy(true);
 241
 242         // @formatter:off
 243         when(policyStatusService.getAllPolicyStatus()).thenReturn(List.of(
 244                         builder.policy(POLICY_A).pdpId(PDP_A).build(),
 245                         builder.policy(POLICY_A).pdpId(PDP_B).build(),
 246                         notDeployed,
 247                         builder.policy(POLICY_C).pdpId(PDP_A).build(),
 248                         builder.policy(POLICY_B).pdpId(PDP_B).state(State.SUCCESS).build()
 249                     ));
 250         // @formatter:on
 251     }
 252
 253     private ToscaConceptIdentifierOptVersion buildPolicyStatusToReturn2() throws PfModelException {
 254         PdpPolicyStatusBuilder builder =
 255             PdpPolicyStatus.builder().pdpGroup(MY_GROUP).pdpType(MY_PDP_TYPE).policy(POLICY_A).policyType(POLICY_TYPE);
 256
 257         PdpPolicyStatus notDeployed = builder.deploy(false).pdpId(PDP_B).state(State.FAILURE).build();
 258
 259         // remaining policies are deployed
 260         builder.deploy(true).state(State.WAITING);
 261
 262         ToscaConceptIdentifierOptVersion optIdent = new ToscaConceptIdentifierOptVersion(POLICY_A);
 263
 264         // @formatter:off
 265         when(policyStatusService.getAllPolicyStatus(optIdent)).thenReturn(List.of(
 266                         builder.policy(POLICY_A).pdpId(PDP_A).build(),
 267                         notDeployed,
 268                         builder.policy(POLICY_A).pdpId(PDP_C).build()
 269                         ));
 270         // @formatter:on
 271         return optIdent;
 272     }
 273 }