main/src/test/java/org/onap/policy/api/main/rest/provider/TestLegacyOperationalPolicyProvider.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy API
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * SPDX-License-Identifier: Apache-2.0
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.api.main.rest.provider;
  24
  25 import static org.assertj.core.api.Assertions.assertThatCode;
  26 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertFalse;
  29 import static org.junit.Assert.assertNotNull;
  30 import static org.junit.Assert.assertTrue;
  31 import static org.junit.Assert.fail;
  32
  33 import java.util.ArrayList;
  34 import java.util.Base64;
  35 import java.util.List;
  36
  37 import org.junit.After;
  38 import org.junit.Before;
  39 import org.junit.Test;
  40 import org.onap.policy.api.main.parameters.ApiParameterGroup;
  41 import org.onap.policy.common.parameters.ParameterService;
  42 import org.onap.policy.common.utils.coder.StandardCoder;
  43 import org.onap.policy.common.utils.resources.ResourceUtils;
  44 import org.onap.policy.models.base.PfModelException;
  45 import org.onap.policy.models.pdp.concepts.Pdp;
  46 import org.onap.policy.models.pdp.concepts.PdpGroup;
  47 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
  48 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
  49 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
  50 import org.onap.policy.models.pdp.enums.PdpState;
  51 import org.onap.policy.models.provider.PolicyModelsProvider;
  52 import org.onap.policy.models.provider.PolicyModelsProviderFactory;
  53 import org.onap.policy.models.provider.PolicyModelsProviderParameters;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
  55 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
  56 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  57 import org.onap.policy.models.tosca.legacy.concepts.LegacyOperationalPolicy;
  58
  59 /**
  60  * This class performs unit test of {@link LegacyOperationalPolicyProvider}
  61  *
  62  * @author Chenfei Gao (cgao@research.att.com)
  63  */
  64 public class TestLegacyOperationalPolicyProvider {
  65
  66     private static LegacyOperationalPolicyProvider operationalPolicyProvider;
  67     private static PolicyTypeProvider policyTypeProvider;
  68     private static PolicyModelsProviderParameters providerParams;
  69     private static ApiParameterGroup apiParamGroup;
  70     private static StandardCoder standardCoder;
  71
  72     private static final String POLICY_RESOURCE = "policies/vCPE.policy.operational.input.json";
  73     private static final String POLICY_TYPE_RESOURCE = "policytypes/onap.policies.controlloop.Operational.json";
  74     private static final String POLICY_TYPE_ID = "onap.policies.controlloop.Operational:1.0.0";
  75     private static final String POLICY_ID = "operational.restart:1.0.0";
  76     private static final String POLICY_NAME = "operational.restart";
  77     private static final String POLICY_VERSION = "1";
  78     private static final String POLICY_TYPE_NAME = "onap.policies.controlloop.Operational";
  79     private static final String POLICY_TYPE_VERSION = "1.0.0";
  80     private static final String LEGACY_MINOR_PATCH_SUFFIX = ".0.0";
  81
  82     /**
  83      * Initializes parameters.
  84      *
  85      * @throws PfModelException the PfModel parsing exception
  86      */
  87     @Before
  88     public void setupParameters() throws PfModelException {
  89
  90         standardCoder = new StandardCoder();
  91         providerParams = new PolicyModelsProviderParameters();
  92         providerParams.setDatabaseDriver("org.h2.Driver");
  93         providerParams.setDatabaseUrl("jdbc:h2:mem:testdb");
  94         providerParams.setDatabaseUser("policy");
  95         providerParams.setDatabasePassword(Base64.getEncoder().encodeToString("P01icY".getBytes()));
  96         providerParams.setPersistenceUnit("ToscaConceptTest");
  97         apiParamGroup = new ApiParameterGroup("ApiGroup", null, providerParams);
  98         ParameterService.register(apiParamGroup, true);
  99         operationalPolicyProvider = new LegacyOperationalPolicyProvider();
 100         policyTypeProvider = new PolicyTypeProvider();
 101     }
 102
 103     /**
 104      * Closes up DB connections and deregisters API parameter group.
 105      *
 106      * @throws PfModelException the PfModel parsing exception
 107      */
 108     @After
 109     public void tearDown() throws PfModelException {
 110
 111         operationalPolicyProvider.close();
 112         policyTypeProvider.close();
 113         ParameterService.deregister(apiParamGroup);
 114     }
 115
 116     @Test
 117     public void testFetchOperationalPolicy() {
 118
 119         assertThatThrownBy(() -> {
 120             operationalPolicyProvider.fetchOperationalPolicy("dummy", null);
 121         }).hasMessage("no policy found for policy: dummy:null");
 122
 123         assertThatThrownBy(() -> {
 124             operationalPolicyProvider.fetchOperationalPolicy("dummy", "dummy");
 125         }).hasMessage("legacy policy version is not an integer");
 126
 127         assertThatCode(() -> {
 128             String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
 129             ToscaServiceTemplate policyTypeServiceTemplate =
 130                     standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
 131             policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
 132
 133             String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 134             LegacyOperationalPolicy policyToCreate = standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 135             LegacyOperationalPolicy createdPolicy = operationalPolicyProvider.createOperationalPolicy(policyToCreate);
 136             assertNotNull(createdPolicy);
 137
 138             policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 139             policyToCreate = standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 140             createdPolicy = operationalPolicyProvider.createOperationalPolicy(policyToCreate);
 141             assertNotNull(createdPolicy);
 142
 143             LegacyOperationalPolicy firstVersion =
 144                     operationalPolicyProvider.fetchOperationalPolicy("operational.restart", "1");
 145             assertNotNull(firstVersion);
 146             assertEquals("1",
 147                     firstVersion.getPolicyVersion());
 148
 149             LegacyOperationalPolicy latestVersion =
 150                     operationalPolicyProvider.fetchOperationalPolicy("operational.restart", null);
 151             assertNotNull(latestVersion);
 152             assertEquals("2",
 153                     latestVersion.getPolicyVersion());
 154         }).doesNotThrowAnyException();
 155
 156         assertThatThrownBy(() -> {
 157             operationalPolicyProvider.fetchOperationalPolicy("operational.restart", "1.0.0");
 158         }).hasMessage("legacy policy version is not an integer");
 159
 160         assertThatThrownBy(() -> {
 161             operationalPolicyProvider.fetchOperationalPolicy("operational.restart", "latest");;
 162         }).hasMessage("legacy policy version is not an integer");
 163
 164         assertThatCode(() -> {
 165             operationalPolicyProvider.deleteOperationalPolicy("operational.restart", "1");
 166             operationalPolicyProvider.deleteOperationalPolicy("operational.restart", "2");
 167             policyTypeProvider.deletePolicyType("onap.policies.controlloop.Operational", "1.0.0");
 168         }).doesNotThrowAnyException();
 169     }
 170
 171     @Test
 172     public void testFetchDeployedOperationalPolicies() {
 173
 174         assertThatThrownBy(() -> {
 175             operationalPolicyProvider.fetchDeployedOperationalPolicies("dummy");
 176         }).hasMessage("could not find policy with ID dummy and type " + POLICY_TYPE_ID + " deployed in any pdp group");
 177
 178         try (PolicyModelsProvider databaseProvider =
 179                 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
 180             assertEquals(0, databaseProvider.getPdpGroups("name").size());
 181             assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
 182
 183             assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
 184             assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
 185
 186             PdpGroup pdpGroup = new PdpGroup();
 187             pdpGroup.setName("group");
 188             pdpGroup.setVersion("1.2.3");
 189             pdpGroup.setPdpGroupState(PdpState.ACTIVE);
 190             pdpGroup.setPdpSubgroups(new ArrayList<>());
 191             List<PdpGroup> groupList = new ArrayList<>();
 192             groupList.add(pdpGroup);
 193
 194             PdpSubGroup pdpSubGroup = new PdpSubGroup();
 195             pdpSubGroup.setPdpType("type");
 196             pdpSubGroup.setDesiredInstanceCount(123);
 197             pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
 198             pdpSubGroup.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier(
 199                     POLICY_TYPE_NAME, POLICY_TYPE_VERSION));
 200             pdpGroup.getPdpSubgroups().add(pdpSubGroup);
 201
 202             Pdp pdp = new Pdp();
 203             pdp.setInstanceId("type-0");
 204             pdp.setMessage("Hello");
 205             pdp.setPdpState(PdpState.ACTIVE);
 206             pdp.setHealthy(PdpHealthStatus.UNKNOWN);
 207             pdpSubGroup.setPdpInstances(new ArrayList<>());
 208             pdpSubGroup.getPdpInstances().add(pdp);
 209
 210             // Create Pdp Groups
 211             assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
 212                     .getDesiredInstanceCount());
 213             assertEquals(1, databaseProvider.getPdpGroups("group").size());
 214
 215             // Create Policy Type
 216             assertThatCode(() -> {
 217                 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
 218                 ToscaServiceTemplate policyTypeServiceTemplate =
 219                         standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
 220                 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
 221             }).doesNotThrowAnyException();
 222
 223             // Create Policy
 224             assertThatCode(() -> {
 225                 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 226                 LegacyOperationalPolicy policyToCreate =
 227                         standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 228                 LegacyOperationalPolicy policyCreated = operationalPolicyProvider
 229                         .createOperationalPolicy(policyToCreate);
 230                 assertEquals("operational.restart", policyCreated.getPolicyId());
 231                 assertEquals("1", policyCreated.getPolicyVersion());
 232                 assertFalse(policyCreated.getContent() == null);
 233             }).doesNotThrowAnyException();
 234
 235             // Test fetchDeployedPolicies (deployedPolicyMap.isEmpty())==true
 236             assertThatThrownBy(
 237                 () -> {
 238                     operationalPolicyProvider.fetchDeployedOperationalPolicies(POLICY_NAME);
 239                 }).hasMessage("could not find policy with ID " + POLICY_NAME + " and type "
 240                     + POLICY_TYPE_ID + " deployed in any pdp group");
 241
 242
 243             // Update pdpSubGroup
 244             pdpSubGroup.setPolicies(new ArrayList<>());
 245             pdpSubGroup.getPolicies().add(
 246                     new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION + LEGACY_MINOR_PATCH_SUFFIX));
 247             assertEquals(1, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
 248                     .getPolicies().size());
 249
 250             // Test fetchDeployedPolicies
 251             assertThatCode(
 252                 () -> {
 253                     operationalPolicyProvider.fetchDeployedOperationalPolicies(POLICY_NAME);
 254                 }).doesNotThrowAnyException();
 255
 256             // Test validateDeleteEligibility exception path(!pdpGroups.isEmpty())
 257             assertThatThrownBy(
 258                 () -> {
 259                     operationalPolicyProvider.deleteOperationalPolicy(
 260                             POLICY_NAME, POLICY_VERSION);
 261                 }).hasMessageContaining("policy with ID " + POLICY_NAME + ":" + POLICY_VERSION
 262                     + " cannot be deleted as it is deployed in pdp groups");
 263         }
 264         catch (Exception exc) {
 265             fail("Test should not throw an exception");
 266         }
 267     }
 268
 269     @Test
 270     public void testCreateOperationalPolicy() {
 271
 272         assertThatThrownBy(() -> {
 273             String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 274             LegacyOperationalPolicy policyToCreate = standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 275             operationalPolicyProvider.createOperationalPolicy(policyToCreate);
 276         }).hasMessage("policy type " + POLICY_TYPE_ID + " for policy " + POLICY_ID + " does not exist");
 277
 278         assertThatCode(() -> {
 279             String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
 280             ToscaServiceTemplate policyTypeServiceTemplate =
 281                     standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
 282             policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
 283
 284             String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 285             LegacyOperationalPolicy policyToCreate = standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 286             LegacyOperationalPolicy createdPolicy = operationalPolicyProvider.createOperationalPolicy(policyToCreate);
 287             assertNotNull(createdPolicy);
 288             assertEquals("operational.restart", createdPolicy.getPolicyId());
 289             assertTrue(createdPolicy.getContent()
 290                     .startsWith("controlLoop%3A%0A%20%20version%3A%202.0.0%0A%20%20"));
 291         }).doesNotThrowAnyException();
 292     }
 293
 294     @Test
 295     public void testDeleteOperationalPolicyException() {
 296         String policyId = "operational.restart";
 297         String policyVersion = "1";
 298         String policyTypeVersion = "1.0.0";
 299         String policyTypeId = "onap.policies.controlloop.Operational";
 300         String legacyMinorPatchSuffix = ".0.0";
 301
 302         try (PolicyModelsProvider databaseProvider =
 303                 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
 304             assertEquals(0, databaseProvider.getPdpGroups("name").size());
 305             assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
 306
 307             assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
 308             assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
 309
 310             PdpGroup pdpGroup = new PdpGroup();
 311             pdpGroup.setName("group");
 312             pdpGroup.setVersion("1.2.3");
 313             pdpGroup.setPdpGroupState(PdpState.ACTIVE);
 314             pdpGroup.setPdpSubgroups(new ArrayList<>());
 315             List<PdpGroup> groupList = new ArrayList<>();
 316             groupList.add(pdpGroup);
 317
 318             PdpSubGroup pdpSubGroup = new PdpSubGroup();
 319             pdpSubGroup.setPdpType("type");
 320             pdpSubGroup.setDesiredInstanceCount(123);
 321             pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
 322             pdpSubGroup.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier(
 323                     policyTypeId, policyTypeVersion));
 324             pdpGroup.getPdpSubgroups().add(pdpSubGroup);
 325
 326             Pdp pdp = new Pdp();
 327             pdp.setInstanceId("type-0");
 328             pdp.setMessage("Hello");
 329             pdp.setPdpState(PdpState.ACTIVE);
 330             pdp.setHealthy(PdpHealthStatus.UNKNOWN);
 331             pdpSubGroup.setPdpInstances(new ArrayList<>());
 332             pdpSubGroup.getPdpInstances().add(pdp);
 333
 334             // Create Pdp Groups
 335             assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
 336                     .getDesiredInstanceCount());
 337             assertEquals(1, databaseProvider.getPdpGroups("group").size());
 338
 339             // Create Policy Type
 340             assertThatCode(() -> {
 341                 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
 342                 ToscaServiceTemplate policyTypeServiceTemplate =
 343                     standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
 344                 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
 345             }).doesNotThrowAnyException();
 346
 347             // Create Policy
 348             assertThatCode(() -> {
 349                 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 350                 LegacyOperationalPolicy policyToCreate =
 351                         standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 352                 LegacyOperationalPolicy createdPolicy =
 353                         operationalPolicyProvider.createOperationalPolicy(policyToCreate);
 354                 assertNotNull(createdPolicy);
 355             }).doesNotThrowAnyException();
 356
 357             // Update pdpSubGroup
 358             pdpSubGroup.setPolicies(new ArrayList<>());
 359             pdpSubGroup.getPolicies().add(new ToscaPolicyIdentifier(policyId, policyVersion + legacyMinorPatchSuffix));
 360             assertEquals(1, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
 361                    .getPolicies().size());
 362             assertThatThrownBy(() -> {
 363                 operationalPolicyProvider.deleteOperationalPolicy(policyId, policyVersion);
 364             }).hasMessageContaining("cannot be deleted as it is deployed in pdp groups");
 365         }
 366         catch (Exception exc) {
 367             fail("Test should not throw an exception");
 368         }
 369     }
 370
 371     @Test
 372     public void testDeleteOperationalPolicy() {
 373
 374         assertThatThrownBy(() -> {
 375             operationalPolicyProvider.deleteOperationalPolicy("dummy", null);
 376         }).hasMessage("legacy policy version is not an integer");
 377
 378         assertThatThrownBy(() -> {
 379             operationalPolicyProvider.deleteOperationalPolicy("dummy", "dummy");
 380         }).hasMessage("legacy policy version is not an integer");
 381
 382         assertThatCode(() -> {
 383             String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
 384             ToscaServiceTemplate policyTypeServiceTemplate =
 385                     standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
 386             policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
 387
 388             String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
 389             LegacyOperationalPolicy policyToCreate = standardCoder.decode(policyString, LegacyOperationalPolicy.class);
 390             LegacyOperationalPolicy createdPolicy = operationalPolicyProvider.createOperationalPolicy(policyToCreate);
 391             assertNotNull(createdPolicy);
 392
 393             LegacyOperationalPolicy deletedPolicy = operationalPolicyProvider
 394                     .deleteOperationalPolicy("operational.restart", "1");
 395             assertNotNull(deletedPolicy);
 396             assertEquals("operational.restart", deletedPolicy.getPolicyId());
 397             assertTrue(deletedPolicy.getContent()
 398                     .startsWith("controlLoop%3A%0A%20%20version%3A%202.0.0%0A%20%20"));
 399         }).doesNotThrowAnyException();
 400
 401         assertThatThrownBy(() -> {
 402             operationalPolicyProvider.deleteOperationalPolicy("operational.restart", "1");
 403         }).hasMessage("no policy found for policy: operational.restart:1");
 404
 405         assertThatCode(() -> {
 406             policyTypeProvider.deletePolicyType("onap.policies.controlloop.Operational", "1.0.0");
 407         }).doesNotThrowAnyException();
 408     }
 409 }