2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 * SPDX-License-Identifier: Apache-2.0
20 * ============LICENSE_END=========================================================
23 package org.onap.policy.api.main.rest.provider;
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;
33 import java.util.ArrayList;
34 import java.util.Base64;
35 import java.util.List;
38 import org.junit.After;
39 import org.junit.Before;
40 import org.junit.Test;
41 import org.onap.policy.api.main.parameters.ApiParameterGroup;
42 import org.onap.policy.common.parameters.ParameterService;
43 import org.onap.policy.common.utils.coder.StandardCoder;
44 import org.onap.policy.common.utils.resources.ResourceUtils;
45 import org.onap.policy.models.base.PfModelException;
46 import org.onap.policy.models.pdp.concepts.Pdp;
47 import org.onap.policy.models.pdp.concepts.PdpGroup;
48 import org.onap.policy.models.pdp.concepts.PdpGroupFilter;
49 import org.onap.policy.models.pdp.concepts.PdpSubGroup;
50 import org.onap.policy.models.pdp.enums.PdpHealthStatus;
51 import org.onap.policy.models.pdp.enums.PdpState;
52 import org.onap.policy.models.provider.PolicyModelsProvider;
53 import org.onap.policy.models.provider.PolicyModelsProviderFactory;
54 import org.onap.policy.models.provider.PolicyModelsProviderParameters;
55 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyIdentifier;
56 import org.onap.policy.models.tosca.authorative.concepts.ToscaPolicyTypeIdentifier;
57 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
58 import org.onap.policy.models.tosca.legacy.concepts.LegacyGuardPolicyInput;
59 import org.onap.policy.models.tosca.legacy.concepts.LegacyGuardPolicyOutput;
62 * This class performs unit test of {@link LegacyGuardPolicyProvider}
64 * @author Chenfei Gao (cgao@research.att.com)
66 public class TestLegacyGuardPolicyProvider {
68 private static LegacyGuardPolicyProvider guardPolicyProvider;
69 private static PolicyTypeProvider policyTypeProvider;
70 private static PolicyModelsProviderParameters providerParams;
71 private static ApiParameterGroup apiParamGroup;
72 private static StandardCoder standardCoder;
74 private static final String POLICY_RESOURCE = "policies/vDNS.policy.guard.frequency.input.json";
75 private static final String POLICY_RESOURCE_VER1 = "policies/vDNS.policy.guard.frequency.input.ver1.json";
76 private static final String POLICY_RESOURCE_VER2 = "policies/vDNS.policy.guard.frequency.input.ver2.json";
77 private static final String POLICY_TYPE_RESOURCE =
78 "policytypes/onap.policies.controlloop.guard.FrequencyLimiter.json";
79 private static final String POLICY_TYPE_ID = "onap.policies.controlloop.guard.FrequencyLimiter:1.0.0";
80 private static final String POLICY_TYPE_NAME = "onap.policies.controlloop.guard.FrequencyLimiter";
81 private static final String POLICY_TYPE_VERSION = "1.0.0";
82 private static final String POLICY_ID = "guard.frequency.scaleout:1.0.0";
83 private static final String POLICY_NAME = "guard.frequency.scaleout";
84 private static final String POLICY_VERSION = "1";
85 private static final String LEGACY_MINOR_PATCH_SUFFIX = ".0.0";
88 * Initializes parameters.
90 * @throws PfModelException the PfModel parsing exception
93 public void setupParameters() throws PfModelException {
95 standardCoder = new StandardCoder();
96 providerParams = new PolicyModelsProviderParameters();
97 providerParams.setDatabaseDriver("org.h2.Driver");
98 providerParams.setDatabaseUrl("jdbc:h2:mem:testdb");
99 providerParams.setDatabaseUser("policy");
100 providerParams.setDatabasePassword(Base64.getEncoder().encodeToString("P01icY".getBytes()));
101 providerParams.setPersistenceUnit("ToscaConceptTest");
102 apiParamGroup = new ApiParameterGroup("ApiGroup", null, providerParams);
103 ParameterService.register(apiParamGroup, true);
104 guardPolicyProvider = new LegacyGuardPolicyProvider();
105 policyTypeProvider = new PolicyTypeProvider();
109 * Closes up DB connections and deregisters API parameter group.
111 * @throws PfModelException the PfModel parsing exception
114 public void tearDown() throws PfModelException {
116 guardPolicyProvider.close();
117 policyTypeProvider.close();
118 ParameterService.deregister(apiParamGroup);
123 public void testFetchGuardPolicy() {
125 assertThatThrownBy(() -> {
126 guardPolicyProvider.fetchGuardPolicy("dummy", null);
127 }).hasMessage("no policy found for policy: dummy:null");
129 assertThatThrownBy(() -> {
130 guardPolicyProvider.fetchGuardPolicy("dummy", "dummy");
131 }).hasMessage("legacy policy version is not an integer");
133 assertThatCode(() -> {
134 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
135 ToscaServiceTemplate policyTypeServiceTemplate =
136 standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
137 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
139 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_VER1);
140 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
141 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
142 assertNotNull(createdPolicy);
143 assertFalse(createdPolicy.isEmpty());
145 policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE_VER2);
146 policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
147 createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
148 assertNotNull(createdPolicy);
149 assertFalse(createdPolicy.isEmpty());
151 Map<String, LegacyGuardPolicyOutput> firstVersion =
152 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "1");
153 assertNotNull(firstVersion);
155 firstVersion.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
157 Map<String, LegacyGuardPolicyOutput> latestVersion =
158 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", null);
159 assertNotNull(latestVersion);
161 latestVersion.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
162 }).doesNotThrowAnyException();
164 assertThatThrownBy(() -> {
165 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "1.0.0");
166 }).hasMessage("legacy policy version is not an integer");
168 assertThatThrownBy(() -> {
169 guardPolicyProvider.fetchGuardPolicy("guard.frequency.scaleout", "latest");
170 }).hasMessage("legacy policy version is not an integer");
172 assertThatCode(() -> {
173 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
174 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "2");
175 policyTypeProvider.deletePolicyType("onap.policies.controlloop.guard.FrequencyLimiter", "1.0.0");
176 }).doesNotThrowAnyException();
180 public void testFetchDeployedGuardPolicies() {
182 assertThatThrownBy(() -> {
183 guardPolicyProvider.fetchDeployedGuardPolicies("dummy");
184 }).hasMessage("No policy type defined for dummy");
186 try (PolicyModelsProvider databaseProvider =
187 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
188 assertEquals(0, databaseProvider.getPdpGroups("name").size());
189 assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
191 assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
192 assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
194 PdpGroup pdpGroup = new PdpGroup();
195 pdpGroup.setName("group");
196 pdpGroup.setVersion("1.2.3");
197 pdpGroup.setPdpGroupState(PdpState.ACTIVE);
198 pdpGroup.setPdpSubgroups(new ArrayList<>());
199 List<PdpGroup> groupList = new ArrayList<>();
200 groupList.add(pdpGroup);
202 PdpSubGroup pdpSubGroup = new PdpSubGroup();
203 pdpSubGroup.setPdpType("type");
204 pdpSubGroup.setDesiredInstanceCount(123);
205 pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
206 pdpSubGroup.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier(
207 POLICY_TYPE_NAME, POLICY_TYPE_VERSION));
208 pdpGroup.getPdpSubgroups().add(pdpSubGroup);
211 pdp.setInstanceId("type-0");
212 pdp.setMessage("Hello");
213 pdp.setPdpState(PdpState.ACTIVE);
214 pdp.setHealthy(PdpHealthStatus.UNKNOWN);
215 pdpSubGroup.setPdpInstances(new ArrayList<>());
216 pdpSubGroup.getPdpInstances().add(pdp);
219 assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
220 .getDesiredInstanceCount());
221 assertEquals(1, databaseProvider.getPdpGroups("group").size());
223 // Create Policy Type
224 assertThatCode(() -> {
225 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
226 ToscaServiceTemplate policyTypeServiceTemplate =
227 standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
228 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
229 }).doesNotThrowAnyException();
232 assertThatCode(() -> {
233 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
234 LegacyGuardPolicyInput policyToCreate =
235 standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
236 Map<String, LegacyGuardPolicyOutput> policyCreated = guardPolicyProvider
237 .createGuardPolicy(policyToCreate);
238 assertFalse(policyCreated.isEmpty());
239 }).doesNotThrowAnyException();
241 // Test fetchDeployedPolicies (deployedPolicyMap.isEmpty())==true
244 guardPolicyProvider.fetchDeployedGuardPolicies(POLICY_NAME);
245 }).hasMessage("could not find policy with ID " + POLICY_NAME + " and type "
246 + POLICY_TYPE_ID + " deployed in any pdp group");
249 // Update pdpSubGroup
250 pdpSubGroup.setPolicies(new ArrayList<>());
251 pdpSubGroup.getPolicies().add(
252 new ToscaPolicyIdentifier(POLICY_NAME, POLICY_VERSION + LEGACY_MINOR_PATCH_SUFFIX));
253 assertEquals(1, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
254 .getPolicies().size());
256 // Test fetchDeployedPolicies
259 guardPolicyProvider.fetchDeployedGuardPolicies(POLICY_NAME);
260 }).doesNotThrowAnyException();
262 // Test validateDeleteEligibility exception path(!pdpGroups.isEmpty())
265 guardPolicyProvider.deleteGuardPolicy(
266 POLICY_NAME, POLICY_VERSION);
267 }).hasMessageContaining("policy with ID " + POLICY_NAME + ":" + POLICY_VERSION
268 + " 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() {
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 assertThatCode(() -> {
285 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
286 ToscaServiceTemplate policyTypeServiceTemplate =
287 standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
288 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
290 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
291 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
292 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
293 assertNotNull(createdPolicy);
294 assertFalse(createdPolicy.isEmpty());
295 assertTrue(createdPolicy.containsKey("guard.frequency.scaleout"));
296 assertEquals("onap.policies.controlloop.guard.FrequencyLimiter",
297 createdPolicy.get("guard.frequency.scaleout").getType());
298 assertEquals("1.0.0", createdPolicy.get("guard.frequency.scaleout").getVersion());
299 }).doesNotThrowAnyException();
303 public void testDeleteGuardPolicyException() {
304 String policyId = "guard.frequency.scaleout";
305 String policyVersion = "1";
306 String policyTypeVersion = "1.0.0";
307 String policyTypeId = "onap.policies.controlloop.guard.FrequencyLimiter";
308 String legacyMinorPatchSuffix = ".0.0";
310 try (PolicyModelsProvider databaseProvider =
311 new PolicyModelsProviderFactory().createPolicyModelsProvider(providerParams)) {
312 assertEquals(0, databaseProvider.getPdpGroups("name").size());
313 assertEquals(0, databaseProvider.getFilteredPdpGroups(PdpGroupFilter.builder().build()).size());
315 assertNotNull(databaseProvider.createPdpGroups(new ArrayList<>()));
316 assertNotNull(databaseProvider.updatePdpGroups(new ArrayList<>()));
318 PdpGroup pdpGroup = new PdpGroup();
319 pdpGroup.setName("group");
320 pdpGroup.setVersion("1.2.3");
321 pdpGroup.setPdpGroupState(PdpState.ACTIVE);
322 pdpGroup.setPdpSubgroups(new ArrayList<>());
323 List<PdpGroup> groupList = new ArrayList<>();
324 groupList.add(pdpGroup);
326 PdpSubGroup pdpSubGroup = new PdpSubGroup();
327 pdpSubGroup.setPdpType("type");
328 pdpSubGroup.setDesiredInstanceCount(123);
329 pdpSubGroup.setSupportedPolicyTypes(new ArrayList<>());
330 pdpSubGroup.getSupportedPolicyTypes().add(new ToscaPolicyTypeIdentifier(
331 policyTypeId, policyTypeVersion));
332 pdpGroup.getPdpSubgroups().add(pdpSubGroup);
335 pdp.setInstanceId("type-0");
336 pdp.setMessage("Hello");
337 pdp.setPdpState(PdpState.ACTIVE);
338 pdp.setHealthy(PdpHealthStatus.UNKNOWN);
339 pdpSubGroup.setPdpInstances(new ArrayList<>());
340 pdpSubGroup.getPdpInstances().add(pdp);
343 assertEquals(123, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
344 .getDesiredInstanceCount());
345 assertEquals(1, databaseProvider.getPdpGroups("group").size());
347 // Create Policy Type
348 assertThatCode(() -> {
349 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
350 ToscaServiceTemplate policyTypeServiceTemplate =
351 standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
352 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
353 }).doesNotThrowAnyException();
356 assertThatCode(() -> {
357 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
358 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString,
359 LegacyGuardPolicyInput.class);
360 Map<String, LegacyGuardPolicyOutput> createdPolicy =
361 guardPolicyProvider.createGuardPolicy(policyToCreate);
362 assertNotNull(createdPolicy);
363 assertFalse(createdPolicy.isEmpty());
364 }).doesNotThrowAnyException();
366 // Update pdpSubGroup
367 pdpSubGroup.setPolicies(new ArrayList<>());
368 pdpSubGroup.getPolicies().add(new ToscaPolicyIdentifier(policyId, policyVersion + legacyMinorPatchSuffix));
369 assertEquals(1, databaseProvider.createPdpGroups(groupList).get(0).getPdpSubgroups().get(0)
370 .getPolicies().size());
371 assertThatThrownBy(() -> {
373 .deleteGuardPolicy("guard.frequency.scaleout", "1");
374 }).hasMessageContaining("cannot be deleted as it is deployed in pdp groups");
376 catch (Exception exc) {
377 fail("Test should not throw an exception");
382 public void testDeleteGuardPolicy() {
383 assertThatThrownBy(() -> {
384 guardPolicyProvider.deleteGuardPolicy("dummy", null);
385 }).hasMessage("legacy policy version is not an integer");
387 assertThatThrownBy(() -> {
388 guardPolicyProvider.deleteGuardPolicy("dummy", "1.0.0");
389 }).hasMessage("legacy policy version is not an integer");
391 assertThatCode(() -> {
392 String policyTypeString = ResourceUtils.getResourceAsString(POLICY_TYPE_RESOURCE);
393 ToscaServiceTemplate policyTypeServiceTemplate =
394 standardCoder.decode(policyTypeString, ToscaServiceTemplate.class);
395 policyTypeProvider.createPolicyType(policyTypeServiceTemplate);
397 String policyString = ResourceUtils.getResourceAsString(POLICY_RESOURCE);
398 LegacyGuardPolicyInput policyToCreate = standardCoder.decode(policyString, LegacyGuardPolicyInput.class);
399 Map<String, LegacyGuardPolicyOutput> createdPolicy = guardPolicyProvider.createGuardPolicy(policyToCreate);
400 assertNotNull(createdPolicy);
401 assertFalse(createdPolicy.isEmpty());
403 Map<String, LegacyGuardPolicyOutput> deletedPolicy = guardPolicyProvider
404 .deleteGuardPolicy("guard.frequency.scaleout", "1");
405 assertNotNull(deletedPolicy);
406 assertFalse(deletedPolicy.isEmpty());
407 assertTrue(deletedPolicy.containsKey("guard.frequency.scaleout"));
408 assertEquals("onap.policies.controlloop.guard.FrequencyLimiter",
409 deletedPolicy.get("guard.frequency.scaleout").getType());
411 deletedPolicy.get("guard.frequency.scaleout").getMetadata().get("policy-version").toString());
413 }).doesNotThrowAnyException();
415 assertThatThrownBy(() -> {
416 guardPolicyProvider.deleteGuardPolicy("guard.frequency.scaleout", "1");
417 }).hasMessage("no policy found for policy: guard.frequency.scaleout:1");
419 assertThatCode(() -> {
420 policyTypeProvider.deletePolicyType("onap.policies.controlloop.guard.FrequencyLimiter", "1.0.0");
421 }).doesNotThrowAnyException();