diff options
Diffstat (limited to 'main/src/test/java/org/onap/policy')
5 files changed, 769 insertions, 0 deletions
diff --git a/main/src/test/java/org/onap/policy/pap/main/service/PdpGroupServiceTest.java b/main/src/test/java/org/onap/policy/pap/main/service/PdpGroupServiceTest.java new file mode 100644 index 00000000..e7090fcf --- /dev/null +++ b/main/src/test/java/org/onap/policy/pap/main/service/PdpGroupServiceTest.java @@ -0,0 +1,199 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Bell Canada. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.main.service; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.Collections; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.onap.policy.common.utils.coder.StandardCoder; +import org.onap.policy.common.utils.resources.ResourceUtils; +import org.onap.policy.models.pdp.concepts.Pdp; +import org.onap.policy.models.pdp.concepts.PdpGroup; +import org.onap.policy.models.pdp.concepts.PdpGroupFilter; +import org.onap.policy.models.pdp.concepts.PdpGroups; +import org.onap.policy.models.pdp.concepts.PdpSubGroup; +import org.onap.policy.models.pdp.enums.PdpHealthStatus; +import org.onap.policy.models.pdp.enums.PdpState; +import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier; +import org.onap.policy.pap.main.rest.CommonPapRestServer; +import org.springframework.beans.factory.annotation.Autowired; + +public class PdpGroupServiceTest extends CommonPapRestServer { + + private static final String FIELD_IS_NULL = "%s is marked non-null but is null"; + + private static final String DEFAULT_GROUP = "defaultGroup"; + + private static final String CREATE_GROUPS = "createGroups"; + + private static final String TYPE = "type"; + + private static final String NAME = "name"; + + private static final String LOCALNAME_IS_NULL = "parameter \"localName\" is null"; + + @Autowired + private PdpGroupService pdpGroupService; + + private PdpGroups groupsToCreate; + + private StandardCoder coder = new StandardCoder(); + + /** + * Setup before tests. + * + * @throws Exception the exception + */ + @Override + @Before + public void setUp() throws Exception { + super.setUp(); + PdpGroups defaultGroup = coder.decode(ResourceUtils.getResourceAsString("e2e/PdpGroups.json"), PdpGroups.class); + pdpGroupService.savePdpGroups(defaultGroup.getGroups()); + groupsToCreate = coder.decode(ResourceUtils.getResourceAsString("e2e/createGroups.json"), PdpGroups.class); + } + + @Test + public void testPdpGroupsCrudSuccess() { + + List<PdpGroup> pdpGroups = pdpGroupService.getPdpGroups(); + assertThat(pdpGroups).hasSize(1); + assertThat(pdpGroups.get(0).getName()).isEqualTo(DEFAULT_GROUP); + + pdpGroupService.savePdpGroups(groupsToCreate.getGroups()); + + assertThat(pdpGroupService.getPdpGroups()).hasSize(2); + + pdpGroups = pdpGroupService.getPdpGroupByName(CREATE_GROUPS); + assertThat(pdpGroups).hasSize(1); + assertThat(pdpGroups.get(0).getName()).isEqualTo(CREATE_GROUPS); + + assertThat(pdpGroupService.getPdpGroupByState(PdpState.PASSIVE)).isEqualTo(pdpGroups); + + List<PdpGroup> activePdpGroups = pdpGroupService.getPdpGroupByState(PdpState.ACTIVE); + assertThat(activePdpGroups).hasSize(1); + assertThat(activePdpGroups.get(0).getPdpSubgroups()).hasSize(3); + + assertThat(pdpGroupService.getPdpGroupByNameAndState(CREATE_GROUPS, PdpState.PASSIVE)).hasSize(1); + assertThat(pdpGroupService.getPdpGroupByNameAndState("invalid-group", PdpState.PASSIVE)).hasSize(0); + assertThat(pdpGroupService.getPdpGroupByNameAndState(DEFAULT_GROUP, PdpState.ACTIVE)).hasSize(1); + + PdpGroupFilter filter = PdpGroupFilter.builder() + .policyTypeList( + Collections.singletonList(new ToscaConceptIdentifier("onap.policies.native.Xacml", "1.0.0"))) + .groupState(PdpState.ACTIVE).build(); + List<PdpGroup> filteredGroups = pdpGroupService.getFilteredPdpGroups(filter); + assertThat(filteredGroups).hasSize(1); + assertThat(filteredGroups.get(0).getName()).isEqualTo(DEFAULT_GROUP); + + pdpGroupService.deletePdpGroup(CREATE_GROUPS); + pdpGroups = pdpGroupService.getPdpGroups(); + assertThat(pdpGroups).hasSize(1); + assertThat(pdpGroups.get(0).getName()).isEqualTo(DEFAULT_GROUP); + } + + @Test + public void testPdpGroupsCrudFailure() { + assertThatThrownBy(() -> pdpGroupService.getPdpGroupByState(null)) + .hasMessage(String.format(FIELD_IS_NULL, "pdpState")); + pdpGroupService.savePdpGroups(groupsToCreate.getGroups()); + assertThatThrownBy(() -> pdpGroupService.deletePdpGroup("invalid-group")) + .hasMessage("delete of PDP group \"invalid-group\" failed, PDP group does not exist"); + assertThat(pdpGroupService.getPdpGroups()).hasSize(2); + + assertThatThrownBy(() -> pdpGroupService.savePdpGroups(null)) + .hasMessage(String.format(FIELD_IS_NULL, "pdpGroups")); + + PdpGroup invalidPdpGroup = new PdpGroup(groupsToCreate.getGroups().get(0)); + invalidPdpGroup.setName("invalidPdpGroup"); + invalidPdpGroup.setPdpGroupState(null); + assertThatThrownBy(() -> pdpGroupService.savePdpGroups(List.of(invalidPdpGroup))) + .hasMessageContaining("Failed saving PdpGroup.") + .hasMessageContaining("item \"pdpGroupState\" value \"null\" INVALID, is null"); + pdpGroupService.deletePdpGroup(CREATE_GROUPS); + } + + @Test + public void testUpdatePdp() { + + assertThatThrownBy(() -> { + pdpGroupService.updatePdp(null, null, new Pdp()); + }).hasMessage(String.format(FIELD_IS_NULL, "pdpGroupName")); + + assertThatThrownBy(() -> { + pdpGroupService.updatePdp(NAME, null, new Pdp()); + }).hasMessage(String.format(FIELD_IS_NULL, "pdpSubGroup")); + + assertThatThrownBy(() -> { + pdpGroupService.updatePdp(NAME, TYPE, null); + }).hasMessage(String.format(FIELD_IS_NULL, "pdp")); + + assertThatThrownBy(() -> { + pdpGroupService.updatePdp(NAME, TYPE, new Pdp()); + }).hasMessage(LOCALNAME_IS_NULL); + + pdpGroupService.savePdpGroups(groupsToCreate.getGroups()); + assertThat(pdpGroupService.getPdpGroups()).hasSize(2); + PdpGroup pdpGroup = pdpGroupService.getPdpGroupByName(CREATE_GROUPS).get(0); + Pdp pdp = pdpGroup.getPdpSubgroups().get(0).getPdpInstances().get(0); + assertThat(pdp.getHealthy()).isEqualTo(PdpHealthStatus.HEALTHY); + + // now update and test + pdp.setHealthy(PdpHealthStatus.NOT_HEALTHY); + pdpGroupService.updatePdp(CREATE_GROUPS, "pdpTypeA", pdp); + PdpGroup updatGroup = pdpGroupService.getPdpGroupByName(CREATE_GROUPS).get(0); + assertThat(updatGroup.getPdpSubgroups().get(0).getPdpInstances().get(0).getHealthy()) + .isEqualTo(PdpHealthStatus.NOT_HEALTHY); + pdpGroupService.deletePdpGroup(CREATE_GROUPS); + } + + @Test + public void testUpdateSubGroup() { + assertThatThrownBy(() -> { + pdpGroupService.updatePdpSubGroup(null, null); + }).hasMessage(String.format(FIELD_IS_NULL, "pdpGroupName")); + + assertThatThrownBy(() -> { + pdpGroupService.updatePdpSubGroup(NAME, null); + }).hasMessage(String.format(FIELD_IS_NULL, "pdpSubGroup")); + + assertThatThrownBy(() -> { + pdpGroupService.updatePdpSubGroup(NAME, new PdpSubGroup()); + }).hasMessage(LOCALNAME_IS_NULL); + + pdpGroupService.savePdpGroups(groupsToCreate.getGroups()); + assertThat(pdpGroupService.getPdpGroups()).hasSize(2); + PdpGroup pdpGroup = pdpGroupService.getPdpGroupByName(CREATE_GROUPS).get(0); + PdpSubGroup pdpSubGroup = pdpGroup.getPdpSubgroups().get(0); + assertThat(pdpSubGroup.getDesiredInstanceCount()).isEqualTo(2); + + // now update and test + pdpSubGroup.setDesiredInstanceCount(1); + pdpGroupService.updatePdpSubGroup(CREATE_GROUPS, pdpSubGroup); + PdpGroup updatGroup = pdpGroupService.getPdpGroupByName(CREATE_GROUPS).get(0); + assertThat(updatGroup.getPdpSubgroups().get(0).getDesiredInstanceCount()).isEqualTo(1); + pdpGroupService.deletePdpGroup(CREATE_GROUPS); + } +} diff --git a/main/src/test/java/org/onap/policy/pap/main/service/PdpStatisticsServiceTest.java b/main/src/test/java/org/onap/policy/pap/main/service/PdpStatisticsServiceTest.java new file mode 100644 index 00000000..86fd9b04 --- /dev/null +++ b/main/src/test/java/org/onap/policy/pap/main/service/PdpStatisticsServiceTest.java @@ -0,0 +1,188 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Bell Canada. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.main.service; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import org.junit.Before; +import org.junit.Test; +import org.onap.policy.models.base.Validated; +import org.onap.policy.models.pdp.concepts.PdpStatistics; +import org.onap.policy.pap.main.rest.CommonPapRestServer; +import org.springframework.beans.factory.annotation.Autowired; + +public class PdpStatisticsServiceTest extends CommonPapRestServer { + + private static final String NAME3 = "name3"; + private static final String NAME1 = "name1"; + private static final String LIST_IS_NULL = "pdpStatisticsList is marked .*ull but is null"; + private static final String GROUP0 = "group0"; + private static final String GROUP = "group"; + private static final String SUBGROUP = "subgroup"; + private static final Instant TIMESTAMP1 = Instant.ofEpochSecond(1078884319); + private static final Instant TIMESTAMP2 = Instant.ofEpochSecond(1078884350); + private static final Integer NUMBER_RECORDS = 10; + + @Autowired + private PdpStatisticsService pdpStatisticsService; + + private PdpStatistics pdpStatistics1; + private PdpStatistics pdpStatistics2; + private PdpStatistics pdpStatistics3; + private PdpStatistics pdpStatistics4; + + /** + * Setup before tests. + * + * @throws Exception the exception + */ + @Override + @Before + public void setUp() throws Exception { + super.setUp(); + pdpStatistics1 = generatePdpStatistics(NAME1, TIMESTAMP1, 1L, GROUP, SUBGROUP); + pdpStatistics2 = generatePdpStatistics("name2", TIMESTAMP1, 2L, GROUP, SUBGROUP); + pdpStatistics3 = generatePdpStatistics(NAME1, TIMESTAMP2, 3L, GROUP, SUBGROUP); + pdpStatistics4 = generatePdpStatistics(NAME3, TIMESTAMP2, 4L, GROUP0, SUBGROUP); + } + + @Test + public void testCreatePdpStatisticsSuccess() { + List<PdpStatistics> createList = List.of(pdpStatistics1, pdpStatistics3, pdpStatistics4, pdpStatistics2); + List<PdpStatistics> createdPdpStatisticsList = pdpStatisticsService.createPdpStatistics(createList); + // these should match AND be in the same order + assertThat(createdPdpStatisticsList).isEqualTo(createList); + } + + @Test + public void testCreatePdpStatisticsFailure() { + + assertThatThrownBy(() -> { + pdpStatisticsService.createPdpStatistics(null); + }).hasMessageMatching(LIST_IS_NULL); + + PdpStatistics pdpStatisticsErr = new PdpStatistics(); + pdpStatisticsErr.setPdpInstanceId("NULL"); + pdpStatisticsErr.setPdpGroupName(GROUP); + + assertThatThrownBy(() -> { + pdpStatisticsService.createPdpStatistics(List.of(pdpStatisticsErr)); + }).hasMessageContaining("pdp statistics").hasMessageContaining("key") + .hasMessageContaining(Validated.IS_A_NULL_KEY); + } + + @Test + public void testFetchDatabaseStatistics() { + + List<PdpStatistics> createList = List.of(pdpStatistics1, pdpStatistics3, pdpStatistics4, pdpStatistics2); + pdpStatisticsService.createPdpStatistics(createList); + Map<String, Map<String, List<PdpStatistics>>> created = + pdpStatisticsService.fetchDatabaseStatistics(NUMBER_RECORDS, null, null); + assertThat(created).hasSize(2); + assertThat(created.get(GROUP0)).hasSize(1); + assertThat(created.get(GROUP0).get(SUBGROUP)).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(3); + + created = pdpStatisticsService.fetchDatabaseStatistics(NUMBER_RECORDS, TIMESTAMP2, TIMESTAMP2); + assertThat(created).hasSize(2); + assertThat(created.get(GROUP0)).hasSize(1); + assertThat(created.get(GROUP0).get(SUBGROUP)).isEqualTo(List.of(pdpStatistics4)); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).isEqualTo(List.of(pdpStatistics3)); + + created = pdpStatisticsService.fetchDatabaseStatistics(NUMBER_RECORDS, null, TIMESTAMP1); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(2); + + created = pdpStatisticsService.fetchDatabaseStatistics(NUMBER_RECORDS, TIMESTAMP2, null); + assertThat(created).hasSize(2); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP0, NUMBER_RECORDS, TIMESTAMP2, TIMESTAMP2); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP0)).hasSize(1); + assertThat(created.get(GROUP0).get(SUBGROUP)).isEqualTo(List.of(pdpStatistics4)); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP, NUMBER_RECORDS, null, TIMESTAMP1); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(2); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP, NUMBER_RECORDS, TIMESTAMP2, null); + assertThat(created).hasSize(1); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP, SUBGROUP, NUMBER_RECORDS, TIMESTAMP1, TIMESTAMP2); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(3); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP, SUBGROUP, NUMBER_RECORDS, null, TIMESTAMP1); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(2); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP, SUBGROUP, NUMBER_RECORDS, TIMESTAMP2, null); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).isEqualTo(List.of(pdpStatistics3)); + + created = pdpStatisticsService.fetchDatabaseStatistics(GROUP, SUBGROUP, NAME1, NUMBER_RECORDS, TIMESTAMP1, + TIMESTAMP2); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(2); + + created = + pdpStatisticsService.fetchDatabaseStatistics(GROUP, SUBGROUP, NAME1, NUMBER_RECORDS, null, TIMESTAMP1); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP)).hasSize(1); + assertThat(created.get(GROUP).get(SUBGROUP)).hasSize(1); + + created = + pdpStatisticsService.fetchDatabaseStatistics(GROUP0, SUBGROUP, NAME3, NUMBER_RECORDS, TIMESTAMP2, null); + assertThat(created).hasSize(1); + assertThat(created.get(GROUP0).get(SUBGROUP)).isEqualTo(List.of(pdpStatistics4)); + } + + private PdpStatistics generatePdpStatistics(String pdpInstanceId, Instant date, Long id, String group, + String subgroup) { + PdpStatistics pdpStatistics11 = new PdpStatistics(); + pdpStatistics11.setPdpInstanceId(pdpInstanceId); + pdpStatistics11.setTimeStamp(date); + pdpStatistics11.setGeneratedId(id); + pdpStatistics11.setPdpGroupName(group); + pdpStatistics11.setPdpSubGroupName(subgroup); + pdpStatistics11.setPolicyDeployCount(2); + pdpStatistics11.setPolicyDeployFailCount(1); + pdpStatistics11.setPolicyDeploySuccessCount(1); + pdpStatistics11.setPolicyExecutedCount(2); + pdpStatistics11.setPolicyExecutedFailCount(1); + pdpStatistics11.setPolicyExecutedSuccessCount(1); + pdpStatistics11.setEngineStats(new ArrayList<>()); + + return pdpStatistics11; + } +} diff --git a/main/src/test/java/org/onap/policy/pap/main/service/PolicyAuditServiceTest.java b/main/src/test/java/org/onap/policy/pap/main/service/PolicyAuditServiceTest.java new file mode 100644 index 00000000..980cdd1a --- /dev/null +++ b/main/src/test/java/org/onap/policy/pap/main/service/PolicyAuditServiceTest.java @@ -0,0 +1,120 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Bell Canada. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.main.service; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.Assert.assertThrows; + +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.List; +import org.junit.Test; +import org.onap.policy.models.base.PfModelRuntimeException; +import org.onap.policy.models.pap.concepts.PolicyAudit; +import org.onap.policy.models.pap.concepts.PolicyAudit.AuditAction; +import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier; +import org.onap.policy.pap.main.rest.CommonPapRestServer; +import org.springframework.beans.factory.annotation.Autowired; + +public class PolicyAuditServiceTest extends CommonPapRestServer { + + private static final String FIELD_IS_NULL = "%s is marked .*ull but is null"; + private static final String GROUP_A = "groupA"; + private static final String GROUP_B = "groupB"; + private static final ToscaConceptIdentifier MY_POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3"); + private static final ToscaConceptIdentifier MY_POLICY2 = new ToscaConceptIdentifier("MyPolicyB", "2.3.4"); + private static final Integer NUMBER_RECORDS = 10; + + @Autowired + private PolicyAuditService policyAuditService; + + @Test + public void testCreateAuditRecordsSuccess() { + policyAuditService.createAuditRecords(generatePolicyAudits(Instant.now(), GROUP_A, MY_POLICY)); + + assertThat(policyAuditService.getAuditRecords(NUMBER_RECORDS, null, null)).hasSize(2); + } + + @Test + public void testCreatePolicyAuditFailure() { + List<PolicyAudit> audits = List.of( + PolicyAudit.builder().pdpType("pdpType").action(AuditAction.DEPLOYMENT).timestamp(Instant.now()).build()); + + assertThrows(PfModelRuntimeException.class, () -> policyAuditService.createAuditRecords(audits)); + assertThatThrownBy(() -> { + policyAuditService.createAuditRecords(audits); + }).isInstanceOf(PfModelRuntimeException.class) + .hasMessageContaining("\"createAuditRecords\" INVALID, item has status INVALID"); + + assertThatThrownBy(() -> { + policyAuditService.createAuditRecords(null); + }).hasMessageMatching(String.format(FIELD_IS_NULL, "audits")); + } + + @Test + public void testGetAuditRecords() { + Instant startDate1 = Instant.now(); + + policyAuditService.createAuditRecords(generatePolicyAudits(startDate1, GROUP_A, MY_POLICY)); + + assertThat(policyAuditService.getAuditRecords(NUMBER_RECORDS, null, null)).hasSize(2); + + assertThat(policyAuditService.getAuditRecords(1, null, null)).hasSize(1); + + // as the start date is 10 min ahead of first record, shouldn't return any records + assertThat(policyAuditService.getAuditRecords(NUMBER_RECORDS, Instant.now().plusSeconds(600), null)).isEmpty(); + + policyAuditService.createAuditRecords(generatePolicyAudits(Instant.now(), GROUP_B, MY_POLICY2)); + + assertThat(policyAuditService.getAuditRecords(NUMBER_RECORDS, null, null)).hasSize(4); + assertThat(policyAuditService.getAuditRecords(NUMBER_RECORDS, null, null)).hasSize(4); + + assertThat(policyAuditService.getAuditRecords(GROUP_A, NUMBER_RECORDS, null, null)).hasSize(2); + assertThat(policyAuditService.getAuditRecords(GROUP_B, NUMBER_RECORDS, null, null)).hasSize(2); + + assertThat(policyAuditService.getAuditRecords(GROUP_A, MY_POLICY.getName(), MY_POLICY.getVersion(), + NUMBER_RECORDS, null, null)).hasSize(2); + assertThat( + policyAuditService.getAuditRecords(GROUP_A, MY_POLICY.getName(), "9.9.9", NUMBER_RECORDS, null, null)) + .hasSize(0); + assertThat(policyAuditService.getAuditRecords(GROUP_B, MY_POLICY.getName(), MY_POLICY.getVersion(), + NUMBER_RECORDS, null, null)).hasSize(0); + assertThat(policyAuditService.getAuditRecords(GROUP_B, MY_POLICY2.getName(), MY_POLICY2.getVersion(), + NUMBER_RECORDS, null, null)).hasSize(2); + assertThat(policyAuditService.getAuditRecords(MY_POLICY2.getName(), MY_POLICY2.getVersion(), NUMBER_RECORDS, + null, null)).hasSize(2); + assertThat( + policyAuditService.getAuditRecords(MY_POLICY.getName(), MY_POLICY.getVersion(), NUMBER_RECORDS, null, null)) + .hasSize(2); + + } + + private List<PolicyAudit> generatePolicyAudits(Instant date, String group, ToscaConceptIdentifier policy) { + PolicyAudit deploy = PolicyAudit.builder().pdpGroup(group).pdpType("pdpType").policy(policy).auditId(1L) + .action(AuditAction.DEPLOYMENT).timestamp(date.truncatedTo(ChronoUnit.SECONDS)).build(); + + PolicyAudit undeploy = PolicyAudit.builder().pdpGroup(group).pdpType("pdpType").policy(policy).auditId(2L) + .action(AuditAction.UNDEPLOYMENT).timestamp(date.plusSeconds(1).truncatedTo(ChronoUnit.SECONDS)).build(); + + return List.of(deploy, undeploy); + } +} diff --git a/main/src/test/java/org/onap/policy/pap/main/service/PolicyStatusServiceTest.java b/main/src/test/java/org/onap/policy/pap/main/service/PolicyStatusServiceTest.java new file mode 100644 index 00000000..2a354036 --- /dev/null +++ b/main/src/test/java/org/onap/policy/pap/main/service/PolicyStatusServiceTest.java @@ -0,0 +1,155 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Bell Canada. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.main.service; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatCode; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.onap.policy.models.base.PfModelRuntimeException; +import org.onap.policy.models.pdp.concepts.PdpPolicyStatus; +import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier; +import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifierOptVersion; +import org.onap.policy.pap.main.rest.CommonPapRestServer; +import org.springframework.beans.factory.annotation.Autowired; + +public class PolicyStatusServiceTest extends CommonPapRestServer { + + private static final String GROUP_A = "groupA"; + private static final String GROUP_B = "groupB"; + private static final ToscaConceptIdentifier MY_POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3"); + private static final ToscaConceptIdentifier MY_POLICY2 = new ToscaConceptIdentifier("MyPolicyB", "2.3.4"); + + @Autowired + private PolicyStatusService policyStatusService; + + private PdpPolicyStatus.PdpPolicyStatusBuilder statusBuilder; + + /** + * Setup before tests. + * + * @throws Exception the exception + */ + @Override + @Before + public void setUp() throws Exception { + super.setUp(); + ToscaConceptIdentifier policyType = new ToscaConceptIdentifier("MyPolicyType", "1.2.4"); + + statusBuilder = PdpPolicyStatus.builder().deploy(true).pdpType("MyPdpType").policy(MY_POLICY) + .policyType(policyType).state(PdpPolicyStatus.State.SUCCESS); + } + + @Test + public void testGetAllPolicyStatus() { + assertThat(policyStatusService.getAllPolicyStatus()).isEmpty(); + + var statusList = createStatusList(); + policyStatusService.cudPolicyStatus(statusList, null, null); + assertThat(policyStatusService.getAllPolicyStatus()).hasSize(5); + policyStatusService.cudPolicyStatus(null, null, statusList); + } + + @Test + public void testGetAllPolicyStatusPfDaoToscaConceptIdentifierOptVersion() { + + assertThatThrownBy(() -> { + policyStatusService.getAllPolicyStatus(null); + }).hasMessageContaining("policy").hasMessageContaining("null"); + + assertThat(policyStatusService.getAllPolicyStatus(new ToscaConceptIdentifierOptVersion("somePdp", null))) + .isEmpty(); + + var statusList = createStatusList(); + policyStatusService.cudPolicyStatus(statusList, null, null); + + assertThat(policyStatusService.getAllPolicyStatus(new ToscaConceptIdentifierOptVersion(MY_POLICY))).hasSize(2); + assertThat( + policyStatusService.getAllPolicyStatus(new ToscaConceptIdentifierOptVersion(MY_POLICY.getName(), null))) + .hasSize(3); + policyStatusService.cudPolicyStatus(null, null, statusList); + } + + @Test + public void testGetGroupPolicyStatus() { + + assertThatThrownBy(() -> { + policyStatusService.getGroupPolicyStatus(null); + }).hasMessage("pdpGroup is marked non-null but is null"); + + assertThat(policyStatusService.getGroupPolicyStatus("PdpGroup0")).isEmpty(); + + var statusList = createStatusList(); + policyStatusService.cudPolicyStatus(statusList, null, null); + assertThat(policyStatusService.getGroupPolicyStatus(GROUP_A)).hasSize(3); + policyStatusService.cudPolicyStatus(null, null, statusList); + } + + @Test + public void testCudPolicyStatus() { + assertThatCode(() -> policyStatusService.cudPolicyStatus(null, null, null)).doesNotThrowAnyException(); + + assertThatThrownBy(() -> { + policyStatusService.cudPolicyStatus(List.of(new PdpPolicyStatus()), null, null); + }).isInstanceOf(PfModelRuntimeException.class); + PdpPolicyStatus invalidStatus = statusBuilder.state(PdpPolicyStatus.State.WAITING).deploy(false).pdpGroup(null) + .pdpId("pdp1").policy(MY_POLICY).build(); + assertThatThrownBy(() -> { + policyStatusService.cudPolicyStatus(List.of(invalidStatus), null, null); + }).isInstanceOf(PfModelRuntimeException.class) + .hasMessageContaining("item \"pdpGroup\" value \"null\" INVALID, is null"); + + // Test create + PdpPolicyStatus status = statusBuilder.state(PdpPolicyStatus.State.WAITING).deploy(false).pdpGroup(GROUP_A) + .pdpId("pdp1").policy(MY_POLICY).build(); + policyStatusService.cudPolicyStatus(List.of(status), null, null); + List<PdpPolicyStatus> createdStatusList = policyStatusService.getAllPolicyStatus(); + assertThat(createdStatusList).hasSize(1); + assertThat(createdStatusList.get(0).getState()).isEqualTo(PdpPolicyStatus.State.WAITING); + + // Test update + status.setDeploy(true); + status.setState(PdpPolicyStatus.State.SUCCESS); + policyStatusService.cudPolicyStatus(null, List.of(status), null); + createdStatusList = policyStatusService.getAllPolicyStatus(); + assertThat(createdStatusList).hasSize(1); + assertThat(createdStatusList.get(0).getState()).isEqualTo(PdpPolicyStatus.State.SUCCESS); + + // Test delete + policyStatusService.cudPolicyStatus(null, null, List.of(status)); + assertThat(policyStatusService.getAllPolicyStatus()).hasSize(0); + } + + private List<PdpPolicyStatus> createStatusList() { + // same name, different version + final ToscaConceptIdentifier policy3 = new ToscaConceptIdentifier(MY_POLICY.getName(), "10.20.30"); + + PdpPolicyStatus id1 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp1").policy(MY_POLICY).build(); + PdpPolicyStatus id2 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp2").policy(MY_POLICY2).build(); + PdpPolicyStatus id3 = statusBuilder.pdpGroup(GROUP_A).pdpId("pdp3").policy(policy3).build(); + PdpPolicyStatus id4 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp4").policy(MY_POLICY).build(); + PdpPolicyStatus id5 = statusBuilder.pdpGroup(GROUP_B).pdpId("pdp5").policy(MY_POLICY2).build(); + return List.of(id1, id2, id3, id4, id5); + } +} diff --git a/main/src/test/java/org/onap/policy/pap/main/service/ToscaServiceTemplateServiceTest.java b/main/src/test/java/org/onap/policy/pap/main/service/ToscaServiceTemplateServiceTest.java new file mode 100644 index 00000000..04c1a281 --- /dev/null +++ b/main/src/test/java/org/onap/policy/pap/main/service/ToscaServiceTemplateServiceTest.java @@ -0,0 +1,107 @@ +/*- + * ============LICENSE_START======================================================= + * Copyright (C) 2022 Bell Canada. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.main.service; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.policy.common.utils.coder.CoderException; +import org.onap.policy.common.utils.coder.StandardCoder; +import org.onap.policy.common.utils.coder.StandardYamlCoder; +import org.onap.policy.common.utils.resources.ResourceUtils; +import org.onap.policy.models.base.PfConceptKey; +import org.onap.policy.models.base.PfModelException; +import org.onap.policy.models.base.PfModelRuntimeException; +import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate; +import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate; +import org.onap.policy.pap.main.repository.ToscaServiceTemplateRepository; + +@RunWith(MockitoJUnitRunner.class) +public class ToscaServiceTemplateServiceTest { + + private static final String VERSION_1 = "1.0.0"; + + private static final String VERSION = "version"; + + private static final String NAME = "name"; + + private static final String INVALID_VERSION_ERR_MSG = + "parameter \"version\": value \"version\", does not match regular expression \"^(\\d+.){2}\\d+$\""; + + @Mock + private ToscaServiceTemplateRepository toscaRepository; + + @InjectMocks + private ToscaServiceTemplateService toscaService; + + private ToscaServiceTemplate serviceTemplate; + + private StandardCoder coder = new StandardYamlCoder(); + + /** + * Set up for tests. + * + * @throws CoderException the exception + */ + @Before + public void setup() throws CoderException { + ToscaServiceTemplate toscaPolicyType = coder + .decode(ResourceUtils.getResourceAsString("e2e/monitoring.policy-type.yaml"), ToscaServiceTemplate.class); + ToscaServiceTemplate toscaPolicy = + coder.decode(ResourceUtils.getResourceAsString("e2e/monitoring.policy.yaml"), ToscaServiceTemplate.class); + serviceTemplate = new ToscaServiceTemplate(toscaPolicyType); + serviceTemplate.setToscaTopologyTemplate(toscaPolicy.getToscaTopologyTemplate()); + Mockito + .when(toscaRepository.findById( + new PfConceptKey(JpaToscaServiceTemplate.DEFAULT_NAME, JpaToscaServiceTemplate.DEFAULT_VERSION))) + .thenReturn(Optional.of(new JpaToscaServiceTemplate(serviceTemplate))); + } + + + @Test + public void testGetPolicyList() throws PfModelException { + assertThatThrownBy(() -> toscaService.getPolicyList(NAME, VERSION)) + .isInstanceOf(PfModelRuntimeException.class).hasRootCauseMessage(INVALID_VERSION_ERR_MSG); + + assertThat(toscaService.getPolicyList(NAME, VERSION_1)).hasSize(0); + + assertThat(toscaService.getPolicyList("onap.restart.tca", VERSION_1)).hasSize(1); + } + + @Test + public void testGetPolicyTypeList() throws PfModelException { + assertThatThrownBy(() -> toscaService.getPolicyTypeList(NAME, VERSION)) + .isInstanceOf(PfModelRuntimeException.class).hasRootCauseMessage(INVALID_VERSION_ERR_MSG); + + assertThat(toscaService.getPolicyTypeList(NAME, VERSION_1)).hasSize(0); + + assertThat(toscaService.getPolicyTypeList("onap.policies.monitoring.cdap.tca.hi.lo.app", VERSION_1)).hasSize(2); + assertThat(toscaService.getPolicyTypeList("onap.policies.Monitoring", VERSION_1)).hasSize(1); + } +} |