2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
6 * Modifications Copyright (C) 2019 Nordix Foundation.
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
20 * SPDX-License-Identifier: Apache-2.0
21 * ============LICENSE_END=========================================================
24 package org.onap.policy.api.main.rest.provider;
26 import static org.assertj.core.api.Assertions.assertThatCode;
27 import static org.assertj.core.api.Assertions.assertThatThrownBy;
28 import static org.junit.Assert.assertEquals;
29 import static org.junit.Assert.assertFalse;
30 import static org.junit.Assert.assertNotNull;
31 import static org.junit.Assert.assertTrue;
32 import static org.junit.Assert.fail;
34 import java.util.ArrayList;
35 import java.util.Base64;
36 import java.util.Collections;
37 import java.util.List;
40 import org.junit.After;
41 import org.junit.Before;
42 import org.junit.Test;
43 import org.onap.policy.api.main.parameters.ApiParameterGroup;
44 import org.onap.policy.common.parameters.ParameterService;
45 import org.onap.policy.common.utils.coder.StandardCoder;
46 import org.onap.policy.common.utils.coder.StandardYamlCoder;
47 import org.onap.policy.common.utils.resources.ResourceUtils;
48 import org.onap.policy.models.base.PfModelException;
49 import org.onap.policy.models.pdp.concepts.Pdp;
50 import org.onap.policy.models.pdp.concepts.PdpGroup;
51 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
52 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
53 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
54 import org.onap.policy.models.pdp.enums.PdpState;
55 import org.onap.policy.models.provider.PolicyModelsProvider;
56 import org.onap.policy.models.provider.PolicyModelsProviderFactory;
57 import org.onap.policy.models.provider.PolicyModelsProviderParameters;
58 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
59 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
60 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
61 import org.onap.policy.models.tosca.legacy.concepts.LegacyGuardPolicyInput;
62 import org.onap.policy.models.tosca.legacy.concepts.LegacyGuardPolicyOutput;
65 * This class performs unit test of {@link LegacyGuardPolicyProvider}.
67 * @author Chenfei Gao (cgao@research.att.com)
69 public class TestLegacyGuardPolicyProvider {
71 private static LegacyGuardPolicyProvider guardPolicyProvider;
72 private static PolicyTypeProvider policyTypeProvider;
73 private static PolicyModelsProviderParameters providerParams;
74 private static ApiParameterGroup apiParamGroup;
75 private static StandardCoder standardCoder;
76 private static StandardYamlCoder standardYamlCoder;
78 private static final String POLICY_RESOURCE = "policies/vDNS.policy.guard.frequency.input.json";
79 private static final String POLICY_RESOURCE_VER1 = "policies/vDNS.policy.guard.frequency.input.ver1.json";
80 private static final String POLICY_RESOURCE_VER2 = "policies/vDNS.policy.guard.frequency.input.ver2.json";
81 private static final String POLICY_RESOURCE_WITH_NO_VERSION =
82 "policies/vDNS.policy.guard.frequency.no.policyversion.json";
83 private static final String POLICY_TYPE_RESOURCE =
84 "policytypes/onap.policies.controlloop.guard.FrequencyLimiter.yaml";
85 private static final String POLICY_TYPE_ID = "onap.policies.controlloop.guard.FrequencyLimiter:1.0.0";
86 private static final String POLICY_TYPE_NAME = "onap.policies.controlloop.guard.FrequencyLimiter";
87 private static final String POLICY_TYPE_VERSION = "1.0.0";
88 private static final String POLICY_ID = "guard.frequency.scaleout:1.0.0";
89 private static final String POLICY_NAME = "guard.frequency.scaleout";
90 private static final String POLICY_VERSION = "1";
91 private static final String LEGACY_MINOR_PATCH_SUFFIX = ".0.0";
94 * Initializes parameters.
96 * @throws PfModelException the PfModel parsing exception
99 public void setupParameters() throws PfModelException {
101 standardCoder = new StandardCoder();
102 standardYamlCoder = new StandardYamlCoder();
103 providerParams = new PolicyModelsProviderParameters();
104 providerParams.setDatabaseDriver("org.h2.Driver");
105 providerParams.setDatabaseUrl("jdbc:h2:mem:testdb");
106 providerParams.setDatabaseUser("policy");
107 providerParams.setDatabasePassword(Base64.getEncoder().encodeToString("P01icY".getBytes()));
108 providerParams.setPersistenceUnit("ToscaConceptTest");
109 apiParamGroup = new ApiParameterGroup("ApiGroup", null, providerParams, Collections.emptyList());
110 ParameterService.register(apiParamGroup, true);
111 guardPolicyProvider = new LegacyGuardPolicyProvider();
112 policyTypeProvider = new PolicyTypeProvider();
116 * Closes up DB connections and deregisters API parameter group.
118 * @throws PfModelException the PfModel parsing exception
121 public void tearDown() throws PfModelException {
123 guardPolicyProvider.close();
124 policyTypeProvider.close();
125 ParameterService.deregister(apiParamGroup);
130 public void testFetchGuardPolicy() {
132 assertThatThrownBy(() -> {
133 guardPolicyProvider.fetchGuardPolicy("dummy", null);
134 }).hasMessage("no policy found for policy: dummy:null");
136 assertThatThrownBy(() -> {
137 guardPolicyProvider.fetchGuardPolicy("dummy", "dummy");
138 }).hasMessage("legacy policy version is not an integer");
140 assertThatCode(() -> {
141 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
142 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
143 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
145 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_VER1);
146 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
147 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
148 assertNotNull(createdPolicy);
149 assertFalse(createdPolicy.isEmpty());
151 policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_VER2);
152 policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
153 createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
154 assertNotNull(createdPolicy);
155 assertFalse(createdPolicy.isEmpty());
157 Map<String, LegacyGuardPolicyOutput> firstVersion =
158 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "1");
159 assertNotNull(firstVersion);
161 firstVersion.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
163 Map<String, LegacyGuardPolicyOutput> latestVersion =
164 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", null);
165 assertNotNull(latestVersion);
167 latestVersion.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
168 }).doesNotThrowAnyException();
170 assertThatThrownBy(() -> {
171 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "1.0.0");
172 }).hasMessage("legacy policy version is not an integer");
174 assertThatThrownBy(() -> {
175 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "latest");
176 }).hasMessage("legacy policy version is not an integer");
178 assertThatCode(() -> {
179 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
180 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "2");
181 policyTypeProvider.deletePolicyType("onap.policies.controlloop.guard.FrequencyLimiter", "1.0.0");
182 }).doesNotThrowAnyException();
186 public void testFetchDeployedGuardPolicies() {
188 assertThatThrownBy(() -> {
189 guardPolicyProvider.fetchDeployedGuardPolicies("dummy");
190 }).hasMessage("No policy type defined for dummy");
192 try (PolicyModelsProvider databaseProvider =
193 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
194 assertEquals(0, databaseProvider.getPdpGroups("name").size());
195 assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
197 assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
198 assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
200 PdpGroup pdpGroup = new PdpGroup();
201 pdpGroup.setName("group");
202 pdpGroup.setVersion("1.2.3");
203 pdpGroup.setPdpGroupState(PdpState.ACTIVE);
204 pdpGroup.setPdpSubgroups(new ArrayList<>());
205 List<PdpGroup> groupList = new ArrayList<>();
206 groupList.add(pdpGroup);
208 PdpSubGroup pdpSubGroup = new PdpSubGroup();
209 pdpSubGroup.setPdpType("type");
210 pdpSubGroup.setDesiredInstanceCount(123);
211 pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
212 pdpSubGroup.getSupportedPolicyTypes()
213 .add(new ToscaPolicyTypeIdentifier(POLICY_TYPE_NAME, POLICY_TYPE_VERSION));
214 pdpGroup.getPdpSubgroups().add(pdpSubGroup);
217 pdp.setInstanceId("type-0");
218 pdp.setMessage("Hello");
219 pdp.setPdpState(PdpState.ACTIVE);
220 pdp.setHealthy(PdpHealthStatus.UNKNOWN);
221 pdpSubGroup.setPdpInstances(new ArrayList<>());
222 pdpSubGroup.getPdpInstances().add(pdp);
225 assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
226 .getDesiredInstanceCount());
227 assertEquals(1, databaseProvider.getPdpGroups("group").size());
229 // Create Policy Type
230 assertThatCode(() -> {
231 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
232 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
233 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
234 }).doesNotThrowAnyException();
237 assertThatCode(() -> {
238 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
239 LegacyGuardPolicyInput policyToCreate =
240 standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
241 Map<String, LegacyGuardPolicyOutput> policyCreated =
242 guardPolicyProvider.createGuardPolicy(policyToCreate);
243 assertFalse(policyCreated.isEmpty());
244 }).doesNotThrowAnyException();
246 // Test fetchDeployedPolicies (deployedPolicyMap.isEmpty())==true
247 assertThatThrownBy(() -> {
248 guardPolicyProvider.fetchDeployedGuardPolicies(POLICY_NAME);
249 }) .hasMessage("could not find policy with ID " + POLICY_NAME + " and type " + POLICY_TYPE_ID
250 + " deployed in any pdp group");
253 // Update pdpSubGroup
254 pdpSubGroup.setPolicies(new ArrayList<>());
255 pdpSubGroup.getPolicies()
256 .add(new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION + LEGACY_MINOR_PATCH_SUFFIX));
258 databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0).getPolicies().size());
260 // Test fetchDeployedPolicies
261 assertThatCode(() -> {
262 guardPolicyProvider.fetchDeployedGuardPolicies(POLICY_NAME);
263 }).doesNotThrowAnyException();
265 // Test validateDeleteEligibility exception path(!pdpGroups.isEmpty())
266 assertThatThrownBy(() -> {
267 guardPolicyProvider.deleteGuardPolicy(POLICY_NAME, POLICY_VERSION);
268 }) .hasMessageContaining("policy with ID " + POLICY_NAME + ":" + POLICY_VERSION
269 + " cannot be deleted as it is deployed in pdp groups");
270 } catch (Exception exc) {
271 fail("Test should not throw an exception");
276 public void testCreateGuardPolicy() throws Exception {
278 assertThatThrownBy(() -> {
279 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
280 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
281 guardPolicyProvider.createGuardPolicy(policyToCreate);
282 }).hasMessage("policy type " + POLICY_TYPE_ID + " for policy " + POLICY_ID + " does not exist");
284 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
285 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
286 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
288 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
289 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
290 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
291 assertNotNull(createdPolicy);
292 assertFalse(createdPolicy.isEmpty());
293 assertTrue(createdPolicy.containsKey("guard.frequency.scaleout"));
294 assertEquals("onap.policies.controlloop.guard.FrequencyLimiter",
295 createdPolicy.get("guard.frequency.scaleout").getType());
296 assertEquals("1.0.0", createdPolicy.get("guard.frequency.scaleout").getVersion());
298 assertThatThrownBy(() -> {
299 String badPolicyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_WITH_NO_VERSION);
300 LegacyGuardPolicyInput badPolicyToCreate =
301 standardCoder.decode(badPolicyString, LegacyGuardPolicyInput.class);
302 guardPolicyProvider.createGuardPolicy(badPolicyToCreate);
303 }).hasMessage("mandatory field 'policy-version' is missing in the policy: guard.frequency.scaleout");
305 assertThatThrownBy(() -> {
306 String duplicatePolicyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
307 LegacyGuardPolicyInput duplicatePolicyToCreate =
308 standardCoder.decode(duplicatePolicyString, LegacyGuardPolicyInput.class);
309 guardPolicyProvider.createGuardPolicy(duplicatePolicyToCreate);
310 }).hasMessage("guard policy guard.frequency.scaleout:1 already exists; its latest version is 1");
314 public void testDeleteGuardPolicyException() {
315 String policyId = "guard.frequency.scaleout";
316 String policyVersion = "1";
317 String policyTypeVersion = "1.0.0";
318 String policyTypeId = "onap.policies.controlloop.guard.FrequencyLimiter";
319 String legacyMinorPatchSuffix = ".0.0";
321 try (PolicyModelsProvider databaseProvider =
322 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
323 assertEquals(0, databaseProvider.getPdpGroups("name").size());
324 assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
326 assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
327 assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
329 PdpGroup pdpGroup = new PdpGroup();
330 pdpGroup.setName("group");
331 pdpGroup.setVersion("1.2.3");
332 pdpGroup.setPdpGroupState(PdpState.ACTIVE);
333 pdpGroup.setPdpSubgroups(new ArrayList<>());
334 List<PdpGroup> groupList = new ArrayList<>();
335 groupList.add(pdpGroup);
337 PdpSubGroup pdpSubGroup = new PdpSubGroup();
338 pdpSubGroup.setPdpType("type");
339 pdpSubGroup.setDesiredInstanceCount(123);
340 pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
341 pdpSubGroup.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier(policyTypeId, policyTypeVersion));
342 pdpGroup.getPdpSubgroups().add(pdpSubGroup);
345 pdp.setInstanceId("type-0");
346 pdp.setMessage("Hello");
347 pdp.setPdpState(PdpState.ACTIVE);
348 pdp.setHealthy(PdpHealthStatus.UNKNOWN);
349 pdpSubGroup.setPdpInstances(new ArrayList<>());
350 pdpSubGroup.getPdpInstances().add(pdp);
353 assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
354 .getDesiredInstanceCount());
355 assertEquals(1, databaseProvider.getPdpGroups("group").size());
357 // Create Policy Type
358 assertThatCode(() -> {
359 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
360 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
361 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
362 }).doesNotThrowAnyException();
365 assertThatCode(() -> {
366 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
367 LegacyGuardPolicyInput policyToCreate =
368 standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
369 Map<String, LegacyGuardPolicyOutput> createdPolicy =
370 guardPolicyProvider.createGuardPolicy(policyToCreate);
371 assertNotNull(createdPolicy);
372 assertFalse(createdPolicy.isEmpty());
373 }).doesNotThrowAnyException();
375 // Update pdpSubGroup
376 pdpSubGroup.setPolicies(new ArrayList<>());
377 pdpSubGroup.getPolicies().add(new ToscaPolicyIdentifier(policyId, policyVersion + legacyMinorPatchSuffix));
379 databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0).getPolicies().size());
380 assertThatThrownBy(() -> {
381 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
382 }).hasMessageContaining("cannot be deleted as it is deployed in pdp groups");
383 } catch (Exception exc) {
384 fail("Test should not throw an exception");
389 public void testDeleteGuardPolicy() {
390 assertThatThrownBy(() -> {
391 guardPolicyProvider.deleteGuardPolicy("dummy", null);
392 }).hasMessage("legacy policy version is not an integer");
394 assertThatThrownBy(() -> {
395 guardPolicyProvider.deleteGuardPolicy("dummy", "1.0.0");
396 }).hasMessage("legacy policy version is not an integer");
398 assertThatCode(() -> {
399 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
400 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
401 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
403 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
404 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
405 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
406 assertNotNull(createdPolicy);
407 assertFalse(createdPolicy.isEmpty());
409 Map<String, LegacyGuardPolicyOutput> deletedPolicy =
410 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
411 assertNotNull(deletedPolicy);
412 assertFalse(deletedPolicy.isEmpty());
413 assertTrue(deletedPolicy.containsKey("guard.frequency.scaleout"));
414 assertEquals("onap.policies.controlloop.guard.FrequencyLimiter",
415 deletedPolicy.get("guard.frequency.scaleout").getType());
417 deletedPolicy.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
419 }).doesNotThrowAnyException();
421 assertThatThrownBy(() -> {
422 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
423 }).hasMessage("no policy found for policy: guard.frequency.scaleout:1");
425 assertThatCode(() -> {
426 policyTypeProvider.deletePolicyType("onap.policies.controlloop.guard.FrequencyLimiter", "1.0.0");
427 }).doesNotThrowAnyException();