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, 2023 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.jupiter.api.Assertions.assertFalse;
  27 import static org.junit.jupiter.api.Assertions.assertTrue;
  28 import static org.mockito.Mockito.when;
  29
  30 import java.util.ArrayList;
  31 import java.util.Collection;
  32 import java.util.Comparator;
  33 import java.util.Iterator;
  34 import java.util.List;
  35 import lombok.NonNull;
  36 import org.junit.jupiter.api.AfterAll;
  37 import org.junit.jupiter.api.BeforeEach;
  38 import org.junit.jupiter.api.Test;
  39 import org.onap.policy.common.utils.services.Registry;
  40 import org.onap.policy.models.pap.concepts.PolicyStatus;
  41 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus;
  42 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.PdpPolicyStatusBuilder;
  43 import org.onap.policy.models.pdp.concepts.PdpPolicyStatus.State;
  44 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  45 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion;
  46
  47 public class TestPolicyStatusProvider extends ProviderSuper {
  48     private static final String MY_GROUP = "MyGroup";
  49     private static final String MY_PDP_TYPE = "MySubGroup";
  50     private static final @NonNull String POLICY_TYPE_VERSION = "1.0.3";
  51     private static final @NonNull String POLICY_A_VERSION = "1.2.3+1";
  52     private static final @NonNull String POLICY_B_VERSION = "1.2.3-1";
  53     private static final @NonNull String POLICY_C_VERSION = "1.2.3";
  54     private static final String PDP_A = "pdpA";
  55     private static final String PDP_B = "pdpB";
  56     private static final String PDP_C = "pdpC";
  57     private static final ToscaConceptIdentifier POLICY_TYPE =
  58         new ToscaConceptIdentifier("MyPolicyType", POLICY_TYPE_VERSION);
  59     private static final ToscaConceptIdentifier POLICY_A =
  60         new ToscaConceptIdentifier("MyPolicyA", POLICY_A_VERSION);
  61     private static final ToscaConceptIdentifier POLICY_B =
  62         new ToscaConceptIdentifier("MyPolicyB", POLICY_B_VERSION);
  63     private static final ToscaConceptIdentifier POLICY_C =
  64         new ToscaConceptIdentifier("MyPolicyC", POLICY_C_VERSION);
  65
  66     private PolicyStatusProvider prov;
  67
  68     @AfterAll
  69     public static void tearDownAfterClass() {
  70         Registry.newRegistry();
  71     }
  72
  73     /**
  74      * Configures mocks and objects.
  75      *
  76      * @throws Exception if an error occurs
  77      */
  78     @Override
  79     @BeforeEach
  80     public void setUp() throws Exception {
  81
  82         super.setUp();
  83
  84         prov = new PolicyStatusProvider(policyStatusService);
  85     }
  86
  87     @Test
  88     void testGetStatus_testAccumulate() {
  89
  90         buildPolicyStatusToReturn1();
  91
  92         List<PolicyStatus> result = new ArrayList<>(prov.getStatus());
  93         result.sort(Comparator.comparing(PolicyStatus::getPolicy));
  94
  95         assertThat(result).hasSize(3);
  96
  97         Iterator<PolicyStatus> iter = result.iterator();
  98
  99         PolicyStatus status = iter.next();
 100         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 101         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 102         assertThat(status.getIncompleteCount()).isEqualTo(2);
 103         assertThat(status.getFailureCount()).isZero();
 104         assertThat(status.getSuccessCount()).isZero();
 105
 106         status = iter.next();
 107         assertThat(status.getPolicy()).isEqualTo(POLICY_B);
 108         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 109         assertThat(status.getIncompleteCount()).isZero();
 110         assertThat(status.getFailureCount()).isZero();
 111         assertThat(status.getSuccessCount()).isEqualTo(1);
 112
 113         status = iter.next();
 114         assertThat(status.getPolicy()).isEqualTo(POLICY_C);
 115         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 116         assertThat(status.getIncompleteCount()).isEqualTo(1);
 117         assertThat(status.getFailureCount()).isZero();
 118         assertThat(status.getSuccessCount()).isZero();
 119     }
 120
 121     @Test
 122     void testGetStatusToscaConceptIdentifierOptVersion() {
 123
 124         ToscaConceptIdentifierOptVersion optIdent = buildPolicyStatusToReturn2();
 125
 126         List<PolicyStatus> result = new ArrayList<>(prov.getStatus(optIdent));
 127         assertThat(result).hasSize(1);
 128
 129         Iterator<PolicyStatus> iter = result.iterator();
 130
 131         PolicyStatus status = iter.next();
 132         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 133         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 134         assertThat(status.getIncompleteCount()).isEqualTo(2);
 135         assertThat(status.getFailureCount()).isZero();
 136         assertThat(status.getSuccessCount()).isZero();
 137     }
 138
 139     @Test
 140     void testGetPolicyStatus() {
 141
 142         buildPolicyStatusToReturn1();
 143
 144         List<PdpPolicyStatus> result = new ArrayList<>(prov.getPolicyStatus());
 145         result.sort(Comparator.comparing(PdpPolicyStatus::getPolicy));
 146
 147         assertThat(result).hasSize(5);
 148         Iterator<PdpPolicyStatus> iter = result.iterator();
 149
 150         PdpPolicyStatus status = iter.next();
 151         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 152         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 153         assertThat(status.getPdpId()).isEqualTo(PDP_A);
 154         assertThat(status.getPdpType()).isEqualTo(MY_PDP_TYPE);
 155         assertThat(status.getPdpGroup()).isEqualTo(MY_GROUP);
 156         assertTrue(status.isDeploy());
 157         assertThat(status.getState()).isEqualTo(State.WAITING);
 158
 159         status = iter.next();
 160         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 161         assertThat(status.getPdpId()).isEqualTo(PDP_B);
 162         assertTrue(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_A);
 168         assertFalse(status.isDeploy());
 169         assertThat(status.getState()).isEqualTo(State.WAITING);
 170
 171         status = iter.next();
 172         assertThat(status.getPolicy()).isEqualTo(POLICY_B);
 173         assertThat(status.getPdpId()).isEqualTo(PDP_B);
 174         assertTrue(status.isDeploy());
 175         assertThat(status.getState()).isEqualTo(State.SUCCESS);
 176     }
 177
 178     @Test
 179     void testGetPolicyStatusByGroupAndPolicyIdVersion() {
 180
 181         ToscaConceptIdentifierOptVersion optIdent = buildPolicyStatusToReturn2();
 182
 183         List<PdpPolicyStatus> result = new ArrayList<>(prov.getPolicyStatus(MY_GROUP, optIdent));
 184         assertThat(result).hasSize(3);
 185
 186         Iterator<PdpPolicyStatus> iter = result.iterator();
 187
 188         PdpPolicyStatus status = iter.next();
 189         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 190         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 191         assertThat(status.getPdpId()).isEqualTo(PDP_A);
 192         assertThat(status.getPdpType()).isEqualTo(MY_PDP_TYPE);
 193         assertThat(status.getPdpGroup()).isEqualTo(MY_GROUP);
 194         assertTrue(status.isDeploy());
 195         assertThat(status.getState()).isEqualTo(State.WAITING);
 196
 197         status = iter.next();
 198         assertThat(status.getPolicy()).isEqualTo(POLICY_A);
 199         assertThat(status.getPolicyType()).isEqualTo(POLICY_TYPE);
 200         assertThat(status.getPdpId()).isEqualTo(PDP_B);
 201         assertThat(status.getPdpType()).isEqualTo(MY_PDP_TYPE);
 202         assertThat(status.getPdpGroup()).isEqualTo(MY_GROUP);
 203         assertFalse(status.isDeploy());
 204         assertThat(status.getState()).isEqualTo(State.FAILURE);
 205     }
 206
 207     @Test
 208     void testGetPolicyStatusByRegexNoMatch() {
 209         buildPolicyStatusToReturn1();
 210         final String pattern = "Hello";
 211
 212         final Collection<PolicyStatus> actual = prov.getByRegex(pattern);
 213         assertThat(actual).isEmpty();
 214     }
 215
 216     @Test
 217     void testGetPolicyStatusOneMatch() {
 218         buildPolicyStatusToReturn1();
 219         final String pattern = "My(We|Po)[li]{0,3}c.A";
 220
 221         final Collection<PolicyStatus> actual = prov.getByRegex(pattern);
 222         assertThat(actual).hasSize(1);
 223
 224         final String actualName = actual.iterator().next().getPolicy().getName();
 225         assertThat(actualName).isEqualTo("MyPolicyA");
 226     }
 227
 228     @Test
 229     void testGetPolicyStatusAllMatch() {
 230         buildPolicyStatusToReturn1();
 231         final String pattern = "My(We|Po)[li]{0,3}c.{2}0*";
 232
 233         final Collection<PolicyStatus> actual = prov.getByRegex(pattern);
 234
 235         assertThat(actual).hasSize(3);
 236     }
 237
 238     private void buildPolicyStatusToReturn1() {
 239
 240         PdpPolicyStatusBuilder builder = PdpPolicyStatus.builder().pdpGroup(MY_GROUP).pdpType(MY_PDP_TYPE)
 241             .policyType(POLICY_TYPE).state(State.WAITING);
 242
 243         PdpPolicyStatus notDeployed = builder.deploy(false).policy(POLICY_B).pdpId(PDP_A).build();
 244
 245         // remaining policies are deployed
 246         builder.deploy(true);
 247
 248         // @formatter:off
 249         when(policyStatusService.getAllPolicyStatus()).thenReturn(List.of(
 250                         builder.policy(POLICY_A).pdpId(PDP_A).build(),
 251                         builder.policy(POLICY_A).pdpId(PDP_B).build(),
 252                         notDeployed,
 253                         builder.policy(POLICY_C).pdpId(PDP_A).build(),
 254                         builder.policy(POLICY_B).pdpId(PDP_B).state(State.SUCCESS).build()
 255                     ));
 256         // @formatter:on
 257     }
 258
 259     private ToscaConceptIdentifierOptVersion buildPolicyStatusToReturn2() {
 260         PdpPolicyStatusBuilder builder =
 261             PdpPolicyStatus.builder().pdpGroup(MY_GROUP).pdpType(MY_PDP_TYPE).policy(POLICY_A).policyType(POLICY_TYPE);
 262
 263         PdpPolicyStatus notDeployed = builder.deploy(false).pdpId(PDP_B).state(State.FAILURE).build();
 264
 265         // remaining policies are deployed
 266         builder.deploy(true).state(State.WAITING);
 267
 268         ToscaConceptIdentifierOptVersion optIdent = new ToscaConceptIdentifierOptVersion(POLICY_A);
 269
 270         // @formatter:off
 271         when(policyStatusService.getAllPolicyStatus(optIdent)).thenReturn(List.of(
 272                         builder.policy(POLICY_A).pdpId(PDP_A).build(),
 273                         notDeployed,
 274                         builder.policy(POLICY_A).pdpId(PDP_C).build()
 275                         ));
 276         // @formatter:on
 277         return optIdent;
 278     }
 279 }