models-pap/src/test/java/org/onap/policy/models/pap/persistence/provider/PolicyAuditProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.models.pap.persistence.provider;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertThrows;
  28 import static org.junit.Assert.assertTrue;
  29
  30 import java.time.Instant;
  31 import java.time.temporal.ChronoUnit;
  32 import java.util.ArrayList;
  33 import java.util.List;
  34 import java.util.Properties;
  35 import java.util.concurrent.TimeUnit;
  36 import org.awaitility.Awaitility;
  37 import org.eclipse.persistence.config.PersistenceUnitProperties;
  38 import org.junit.After;
  39 import org.junit.Before;
  40 import org.junit.Test;
  41 import org.onap.policy.models.base.PfModelRuntimeException;
  42 import org.onap.policy.models.dao.DaoParameters;
  43 import org.onap.policy.models.dao.PfDao;
  44 import org.onap.policy.models.dao.PfDaoFactory;
  45 import org.onap.policy.models.dao.impl.DefaultPfDao;
  46 import org.onap.policy.models.pap.concepts.PolicyAudit;
  47 import org.onap.policy.models.pap.concepts.PolicyAudit.AuditAction;
  48 import org.onap.policy.models.pap.persistence.provider.PolicyAuditProvider.AuditFilter;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  50
  51 /**
  52  * Class for unit testing {@link PolicyAuditProvider}.
  53  *
  54  * @author Adheli Tavares (adheli.tavares@est.tech)
  55  *
  56  */
  57 public class PolicyAuditProviderTest {
  58
  59     private static final String FIELD_IS_NULL = "%s is marked .*ull but is null";
  60     private static final String GROUP_A = "groupA";
  61     private static final String GROUP_B = "groupB";
  62     private static final ToscaConceptIdentifier MY_POLICY = new ToscaConceptIdentifier("MyPolicy", "1.2.3");
  63     private static final ToscaConceptIdentifier MY_POLICY2 = new ToscaConceptIdentifier("MyPolicyB", "2.3.4");
  64     private static final Integer NUMBER_RECORDS = 10;
  65
  66     private PfDao pfDao;
  67
  68     /**
  69      * Set up the DAO towards the database.
  70      *
  71      * @throws Exception on database errors
  72      */
  73     @Before
  74     public void setupDao() throws Exception {
  75         final DaoParameters daoParameters = new DaoParameters();
  76         daoParameters.setPluginClass(DefaultPfDao.class.getName());
  77
  78         daoParameters.setPersistenceUnit("ToscaConceptTest");
  79
  80         Properties jdbcProperties = new Properties();
  81         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "policy");
  82         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "P01icY");
  83
  84         if (System.getProperty("USE-MARIADB") != null) {
  85             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.mariadb.jdbc.Driver");
  86             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:mariadb://localhost:3306/policy");
  87         } else {
  88             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
  89             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:PolicyAuditProviderTest");
  90         }
  91
  92         daoParameters.setJdbcProperties(jdbcProperties);
  93
  94         pfDao = new PfDaoFactory().createPfDao(daoParameters);
  95         pfDao.init(daoParameters);
  96     }
  97
  98     @After
  99     public void teardown() {
 100         pfDao.close();
 101     }
 102
 103     @Test
 104     public void testCreatePolicyAudit() {
 105         PolicyAuditProvider provider = new PolicyAuditProvider();
 106
 107         Instant date = Instant.now();
 108         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_A, MY_POLICY));
 109
 110         List<PolicyAudit> records = provider.getAuditRecords(pfDao, NUMBER_RECORDS);
 111         assertThat(records).hasSize(2);
 112
 113         // as the start date is 10 min ahead of first record, shouldn't return any records
 114         List<PolicyAudit> emptyList = provider.getAuditRecords(pfDao,
 115                 AuditFilter.builder().fromDate(Instant.now().plusSeconds(600)).build(), 600);
 116         assertThat(emptyList).isEmpty();
 117     }
 118
 119     @Test
 120     public void testCreatePolicyAuditInvalid() {
 121         PolicyAuditProvider provider = new PolicyAuditProvider();
 122
 123         List<PolicyAudit> audits = List.of(PolicyAudit.builder().pdpType("pdpType").action(AuditAction.DEPLOYMENT)
 124                 .timestamp(Instant.now()).build());
 125
 126         assertThrows(PfModelRuntimeException.class, () -> provider.createAuditRecords(pfDao, audits));
 127
 128         List<PolicyAudit> records = provider.getAuditRecords(pfDao, NUMBER_RECORDS);
 129         assertThat(records).isEmpty();
 130     }
 131
 132     @Test
 133     public void testFilters() {
 134         PolicyAuditProvider provider = new PolicyAuditProvider();
 135
 136         Instant date = Instant.now().truncatedTo(ChronoUnit.SECONDS);
 137         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_A, MY_POLICY));
 138         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_B, MY_POLICY));
 139         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_B, MY_POLICY2));
 140         Awaitility.await().pollDelay(3, TimeUnit.SECONDS).until(() -> {
 141             return true;
 142         });
 143
 144         List<PolicyAudit> records = provider.getAuditRecords(pfDao,
 145                 AuditFilter.builder().fromDate(date).toDate(Instant.now()).recordNum(NUMBER_RECORDS).build());
 146         assertThat(records).hasSize(6);
 147
 148         List<PolicyAudit> recordsWithGroupB =
 149                         provider.getAuditRecords(pfDao,
 150                                         AuditFilter.builder().pdpGroup(GROUP_B).recordNum(NUMBER_RECORDS).build());
 151         assertThat(recordsWithGroupB).hasSize(4);
 152
 153         List<PolicyAudit> recordsWithActionDeploy = provider.getAuditRecords(pfDao,
 154                 AuditFilter.builder().action(AuditAction.DEPLOYMENT).recordNum(NUMBER_RECORDS).build());
 155         assertThat(recordsWithActionDeploy).hasSize(3);
 156
 157         List<PolicyAudit> recordsWithMyPolicy = provider.getAuditRecords(pfDao,
 158                         AuditFilter.builder().name(MY_POLICY.getName()).version(MY_POLICY.getVersion())
 159                                         .recordNum(NUMBER_RECORDS).build());
 160         assertThat(recordsWithMyPolicy).hasSize(4);
 161     }
 162
 163     @Test
 164     public void testFiltersOld() {
 165         PolicyAuditProvider provider = new PolicyAuditProvider();
 166
 167         Instant date = Instant.now().truncatedTo(ChronoUnit.SECONDS);
 168         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_A, MY_POLICY));
 169         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_B, MY_POLICY));
 170         provider.createAuditRecords(pfDao, generatePolicyAudits(date, GROUP_B, MY_POLICY2));
 171         Awaitility.await().pollDelay(3, TimeUnit.SECONDS).until(() -> {
 172             return true;
 173         });
 174
 175         List<PolicyAudit> records = provider.getAuditRecords(pfDao,
 176                 AuditFilter.builder().fromDate(date).toDate(Instant.now()).build(), NUMBER_RECORDS);
 177         assertThat(records).hasSize(6);
 178
 179         List<PolicyAudit> recordsWithGroupB =
 180                 provider.getAuditRecords(pfDao, AuditFilter.builder().pdpGroup(GROUP_B).build(), NUMBER_RECORDS);
 181         assertThat(recordsWithGroupB).hasSize(4);
 182
 183         List<PolicyAudit> recordsWithActionDeploy = provider.getAuditRecords(pfDao,
 184                 AuditFilter.builder().action(AuditAction.DEPLOYMENT).build(), NUMBER_RECORDS);
 185         assertThat(recordsWithActionDeploy).hasSize(3);
 186
 187         List<PolicyAudit> recordsWithMyPolicy = provider.getAuditRecords(pfDao,
 188                 AuditFilter.builder().name(MY_POLICY.getName()).version(MY_POLICY.getVersion()).build(),
 189                 NUMBER_RECORDS);
 190         assertThat(recordsWithMyPolicy).hasSize(4);
 191     }
 192
 193     @Test
 194     public void testLoadRecordsForLimit() {
 195         PolicyAuditProvider provider = new PolicyAuditProvider();
 196
 197         List<PolicyAudit> loadAudits = new ArrayList<>();
 198
 199         // going to create 102 records.
 200         for (int i = 0; i <= 50; i++) {
 201             loadAudits.addAll(generatePolicyAudits(Instant.now().plusSeconds(i), GROUP_A, MY_POLICY));
 202         }
 203
 204         provider.createAuditRecords(pfDao, loadAudits);
 205
 206         List<PolicyAudit> records = provider.getAuditRecords(pfDao, NUMBER_RECORDS);
 207         assertThat(records).hasSize(10);
 208
 209         // check that is being ordered
 210         assertTrue(records.get(0).getTimestamp().isAfter(records.get(9).getTimestamp()));
 211         assertEquals(loadAudits.get(loadAudits.size() - 1).getTimestamp(), records.get(0).getTimestamp());
 212
 213         // try to get 102 records should return 100
 214         records = provider.getAuditRecords(pfDao, 102);
 215         assertThat(records).hasSize(100);
 216     }
 217
 218     @Test
 219     public void policyProviderExceptions() {
 220         PolicyAuditProvider provider = new PolicyAuditProvider();
 221
 222         assertThatThrownBy(() -> {
 223             provider.createAuditRecords(null, null);
 224         }).hasMessageMatching(String.format(FIELD_IS_NULL, "dao"));
 225
 226         assertThatThrownBy(() -> {
 227             provider.createAuditRecords(pfDao, null);
 228         }).hasMessageMatching(String.format(FIELD_IS_NULL, "audits"));
 229
 230         assertThatThrownBy(() -> {
 231             provider.getAuditRecords(null, NUMBER_RECORDS);
 232         }).hasMessageMatching(String.format(FIELD_IS_NULL, "dao"));
 233
 234         assertThatThrownBy(() -> {
 235             provider.getAuditRecords(pfDao, (Integer) null);
 236         }).hasMessageMatching(String.format(FIELD_IS_NULL, "numRecords"));
 237
 238         assertThatThrownBy(() -> {
 239             provider.getAuditRecords(null, AuditFilter.builder().build(), NUMBER_RECORDS);
 240         }).hasMessageMatching(String.format(FIELD_IS_NULL, "dao"));
 241
 242         assertThatThrownBy(() -> {
 243             provider.getAuditRecords(pfDao, AuditFilter.builder().build(), null);
 244         }).hasMessageMatching(String.format(FIELD_IS_NULL, "numRecords"));
 245
 246         assertThatThrownBy(() -> {
 247             provider.getAuditRecords(pfDao, null, NUMBER_RECORDS);
 248         }).hasMessageMatching(String.format(FIELD_IS_NULL, "auditFilter"));
 249     }
 250
 251     @Test
 252     public void testAuditFiltersIsEmpty() {
 253         AuditFilter emptyFilter = AuditFilter.builder().build();
 254         assertTrue(emptyFilter.isEmpty());
 255
 256         AuditFilter stringsEmpty =
 257                 AuditFilter.builder().action(AuditAction.DEPLOYMENT).fromDate(Instant.MIN).toDate(Instant.MAX).build();
 258         assertFalse(stringsEmpty.isEmpty());
 259
 260         AuditFilter filter = AuditFilter.builder().fromDate(Instant.MIN).toDate(Instant.MAX).build();
 261         assertFalse(filter.isEmpty());
 262         filter = AuditFilter.builder().fromDate(Instant.MIN).build();
 263         assertFalse(filter.isEmpty());
 264         filter = AuditFilter.builder().toDate(Instant.MAX).build();
 265         assertFalse(filter.isEmpty());
 266         filter = AuditFilter.builder().name("myPolicy").toDate(Instant.MAX).build();
 267         assertFalse(filter.isEmpty());
 268     }
 269
 270     private List<PolicyAudit> generatePolicyAudits(Instant date, String group, ToscaConceptIdentifier policy) {
 271         // @formatter:off
 272         PolicyAudit deploy = PolicyAudit.builder()
 273                                         .pdpGroup(group)
 274                                         .pdpType("pdpType")
 275                                         .policy(policy)
 276                                         .action(AuditAction.DEPLOYMENT)
 277                                         .timestamp(date.truncatedTo(ChronoUnit.SECONDS))
 278                                         .build();
 279
 280         PolicyAudit undeploy = PolicyAudit.builder()
 281                                         .pdpGroup(group)
 282                                         .pdpType("pdpType")
 283                                         .policy(policy)
 284                                         .action(AuditAction.UNDEPLOYMENT)
 285                                         .timestamp(date.plusSeconds(1).truncatedTo(ChronoUnit.SECONDS))
 286                                         .build();
 287         // @formatter:on
 288
 289         return List.of(deploy, undeploy);
 290     }
 291 }