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_TYPE_RESOURCE =
82 "policytypes/onap.policies.controlloop.guard.FrequencyLimiter.yaml";
83 private static final String POLICY_TYPE_ID = "onap.policies.controlloop.guard.FrequencyLimiter:1.0.0";
84 private static final String POLICY_TYPE_NAME = "onap.policies.controlloop.guard.FrequencyLimiter";
85 private static final String POLICY_TYPE_VERSION = "1.0.0";
86 private static final String POLICY_ID = "guard.frequency.scaleout:1.0.0";
87 private static final String POLICY_NAME = "guard.frequency.scaleout";
88 private static final String POLICY_VERSION = "1";
89 private static final String LEGACY_MINOR_PATCH_SUFFIX = ".0.0";
92 * Initializes parameters.
94 * @throws PfModelException the PfModel parsing exception
97 public void setupParameters() throws PfModelException {
99 standardCoder = new StandardCoder();
100 standardYamlCoder = new StandardYamlCoder();
101 providerParams = new PolicyModelsProviderParameters();
102 providerParams.setDatabaseDriver("org.h2.Driver");
103 providerParams.setDatabaseUrl("jdbc:h2:mem:testdb");
104 providerParams.setDatabaseUser("policy");
105 providerParams.setDatabasePassword(Base64.getEncoder().encodeToString("P01icY".getBytes()));
106 providerParams.setPersistenceUnit("ToscaConceptTest");
107 apiParamGroup = new ApiParameterGroup("ApiGroup", null, providerParams, Collections.emptyList());
108 ParameterService.register(apiParamGroup, true);
109 guardPolicyProvider = new LegacyGuardPolicyProvider();
110 policyTypeProvider = new PolicyTypeProvider();
114 * Closes up DB connections and deregisters API parameter group.
116 * @throws PfModelException the PfModel parsing exception
119 public void tearDown() throws PfModelException {
121 guardPolicyProvider.close();
122 policyTypeProvider.close();
123 ParameterService.deregister(apiParamGroup);
128 public void testFetchGuardPolicy() {
130 assertThatThrownBy(() -> {
131 guardPolicyProvider.fetchGuardPolicy("dummy", null);
132 }).hasMessage("no policy found for policy: dummy:null");
134 assertThatThrownBy(() -> {
135 guardPolicyProvider.fetchGuardPolicy("dummy", "dummy");
136 }).hasMessage("legacy policy version is not an integer");
138 assertThatCode(() -> {
139 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
140 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
141 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
143 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_VER1);
144 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
145 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
146 assertNotNull(createdPolicy);
147 assertFalse(createdPolicy.isEmpty());
149 policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_VER2);
150 policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
151 createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
152 assertNotNull(createdPolicy);
153 assertFalse(createdPolicy.isEmpty());
155 Map<String, LegacyGuardPolicyOutput> firstVersion =
156 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "1");
157 assertNotNull(firstVersion);
159 firstVersion.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
161 Map<String, LegacyGuardPolicyOutput> latestVersion =
162 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", null);
163 assertNotNull(latestVersion);
165 latestVersion.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
166 }).doesNotThrowAnyException();
168 assertThatThrownBy(() -> {
169 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "1.0.0");
170 }).hasMessage("legacy policy version is not an integer");
172 assertThatThrownBy(() -> {
173 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "latest");
174 }).hasMessage("legacy policy version is not an integer");
176 assertThatCode(() -> {
177 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
178 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "2");
179 policyTypeProvider.deletePolicyType("onap.policies.controlloop.guard.FrequencyLimiter", "1.0.0");
180 }).doesNotThrowAnyException();
184 public void testFetchDeployedGuardPolicies() {
186 assertThatThrownBy(() -> {
187 guardPolicyProvider.fetchDeployedGuardPolicies("dummy");
188 }).hasMessage("No policy type defined for dummy");
190 try (PolicyModelsProvider databaseProvider =
191 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
192 assertEquals(0, databaseProvider.getPdpGroups("name").size());
193 assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
195 assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
196 assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
198 PdpGroup pdpGroup = new PdpGroup();
199 pdpGroup.setName("group");
200 pdpGroup.setVersion("1.2.3");
201 pdpGroup.setPdpGroupState(PdpState.ACTIVE);
202 pdpGroup.setPdpSubgroups(new ArrayList<>());
203 List<PdpGroup> groupList = new ArrayList<>();
204 groupList.add(pdpGroup);
206 PdpSubGroup pdpSubGroup = new PdpSubGroup();
207 pdpSubGroup.setPdpType("type");
208 pdpSubGroup.setDesiredInstanceCount(123);
209 pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
210 pdpSubGroup.getSupportedPolicyTypes()
211 .add(new ToscaPolicyTypeIdentifier(POLICY_TYPE_NAME, POLICY_TYPE_VERSION));
212 pdpGroup.getPdpSubgroups().add(pdpSubGroup);
215 pdp.setInstanceId("type-0");
216 pdp.setMessage("Hello");
217 pdp.setPdpState(PdpState.ACTIVE);
218 pdp.setHealthy(PdpHealthStatus.UNKNOWN);
219 pdpSubGroup.setPdpInstances(new ArrayList<>());
220 pdpSubGroup.getPdpInstances().add(pdp);
223 assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
224 .getDesiredInstanceCount());
225 assertEquals(1, databaseProvider.getPdpGroups("group").size());
227 // Create Policy Type
228 assertThatCode(() -> {
229 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
230 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
231 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
232 }).doesNotThrowAnyException();
235 assertThatCode(() -> {
236 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
237 LegacyGuardPolicyInput policyToCreate =
238 standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
239 Map<String, LegacyGuardPolicyOutput> policyCreated =
240 guardPolicyProvider.createGuardPolicy(policyToCreate);
241 assertFalse(policyCreated.isEmpty());
242 }).doesNotThrowAnyException();
244 // Test fetchDeployedPolicies (deployedPolicyMap.isEmpty())==true
245 assertThatThrownBy(() -> {
246 guardPolicyProvider.fetchDeployedGuardPolicies(POLICY_NAME);
247 }) .hasMessage("could not find policy with ID " + POLICY_NAME + " and type " + POLICY_TYPE_ID
248 + " deployed in any pdp group");
251 // Update pdpSubGroup
252 pdpSubGroup.setPolicies(new ArrayList<>());
253 pdpSubGroup.getPolicies()
254 .add(new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION + LEGACY_MINOR_PATCH_SUFFIX));
256 databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0).getPolicies().size());
258 // Test fetchDeployedPolicies
259 assertThatCode(() -> {
260 guardPolicyProvider.fetchDeployedGuardPolicies(POLICY_NAME);
261 }).doesNotThrowAnyException();
263 // Test validateDeleteEligibility exception path(!pdpGroups.isEmpty())
264 assertThatThrownBy(() -> {
265 guardPolicyProvider.deleteGuardPolicy(POLICY_NAME, POLICY_VERSION);
266 }) .hasMessageContaining("policy with ID " + POLICY_NAME + ":" + POLICY_VERSION
267 + " cannot be deleted as it is deployed in pdp groups");
268 } catch (Exception exc) {
269 fail("Test should not throw an exception");
274 public void testCreateGuardPolicy() {
276 assertThatThrownBy(() -> {
277 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
278 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
279 guardPolicyProvider.createGuardPolicy(policyToCreate);
280 }).hasMessage("policy type " + POLICY_TYPE_ID + " for policy " + POLICY_ID + " does not exist");
282 assertThatCode(() -> {
283 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
284 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
285 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
287 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
288 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
289 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
290 assertNotNull(createdPolicy);
291 assertFalse(createdPolicy.isEmpty());
292 assertTrue(createdPolicy.containsKey("guard.frequency.scaleout"));
293 assertEquals("onap.policies.controlloop.guard.FrequencyLimiter",
294 createdPolicy.get("guard.frequency.scaleout").getType());
295 assertEquals("1.0.0", createdPolicy.get("guard.frequency.scaleout").getVersion());
296 }).doesNotThrowAnyException();
300 public void testDeleteGuardPolicyException() {
301 String policyId = "guard.frequency.scaleout";
302 String policyVersion = "1";
303 String policyTypeVersion = "1.0.0";
304 String policyTypeId = "onap.policies.controlloop.guard.FrequencyLimiter";
305 String legacyMinorPatchSuffix = ".0.0";
307 try (PolicyModelsProvider databaseProvider =
308 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
309 assertEquals(0, databaseProvider.getPdpGroups("name").size());
310 assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
312 assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
313 assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
315 PdpGroup pdpGroup = new PdpGroup();
316 pdpGroup.setName("group");
317 pdpGroup.setVersion("1.2.3");
318 pdpGroup.setPdpGroupState(PdpState.ACTIVE);
319 pdpGroup.setPdpSubgroups(new ArrayList<>());
320 List<PdpGroup> groupList = new ArrayList<>();
321 groupList.add(pdpGroup);
323 PdpSubGroup pdpSubGroup = new PdpSubGroup();
324 pdpSubGroup.setPdpType("type");
325 pdpSubGroup.setDesiredInstanceCount(123);
326 pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
327 pdpSubGroup.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier(policyTypeId, policyTypeVersion));
328 pdpGroup.getPdpSubgroups().add(pdpSubGroup);
331 pdp.setInstanceId("type-0");
332 pdp.setMessage("Hello");
333 pdp.setPdpState(PdpState.ACTIVE);
334 pdp.setHealthy(PdpHealthStatus.UNKNOWN);
335 pdpSubGroup.setPdpInstances(new ArrayList<>());
336 pdpSubGroup.getPdpInstances().add(pdp);
339 assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
340 .getDesiredInstanceCount());
341 assertEquals(1, databaseProvider.getPdpGroups("group").size());
343 // Create Policy Type
344 assertThatCode(() -> {
345 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
346 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
347 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
348 }).doesNotThrowAnyException();
351 assertThatCode(() -> {
352 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
353 LegacyGuardPolicyInput policyToCreate =
354 standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
355 Map<String, LegacyGuardPolicyOutput> createdPolicy =
356 guardPolicyProvider.createGuardPolicy(policyToCreate);
357 assertNotNull(createdPolicy);
358 assertFalse(createdPolicy.isEmpty());
359 }).doesNotThrowAnyException();
361 // Update pdpSubGroup
362 pdpSubGroup.setPolicies(new ArrayList<>());
363 pdpSubGroup.getPolicies().add(new ToscaPolicyIdentifier(policyId, policyVersion + legacyMinorPatchSuffix));
365 databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0).getPolicies().size());
366 assertThatThrownBy(() -> {
367 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
368 }).hasMessageContaining("cannot be deleted as it is deployed in pdp groups");
369 } catch (Exception exc) {
370 fail("Test should not throw an exception");
375 public void testDeleteGuardPolicy() {
376 assertThatThrownBy(() -> {
377 guardPolicyProvider.deleteGuardPolicy("dummy", null);
378 }).hasMessage("legacy policy version is not an integer");
380 assertThatThrownBy(() -> {
381 guardPolicyProvider.deleteGuardPolicy("dummy", "1.0.0");
382 }).hasMessage("legacy policy version is not an integer");
384 assertThatCode(() -> {
385 ToscaServiceTemplate policyTypeServiceTemplate = standardYamlCoder.decode(
386 ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE), ToscaServiceTemplate.class);
387 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
389 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
390 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
391 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
392 assertNotNull(createdPolicy);
393 assertFalse(createdPolicy.isEmpty());
395 Map<String, LegacyGuardPolicyOutput> deletedPolicy =
396 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
397 assertNotNull(deletedPolicy);
398 assertFalse(deletedPolicy.isEmpty());
399 assertTrue(deletedPolicy.containsKey("guard.frequency.scaleout"));
400 assertEquals("onap.policies.controlloop.guard.FrequencyLimiter",
401 deletedPolicy.get("guard.frequency.scaleout").getType());
403 deletedPolicy.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
405 }).doesNotThrowAnyException();
407 assertThatThrownBy(() -> {
408 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
409 }).hasMessage("no policy found for policy: guard.frequency.scaleout:1");
411 assertThatCode(() -> {
412 policyTypeProvider.deletePolicyType("onap.policies.controlloop.guard.FrequencyLimiter", "1.0.0");
413 }).doesNotThrowAnyException();