models-pdp/src/test/java/org/onap/policy/models/pdp/persistence/provider/PdpStatisticsProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2020-2021 Nordix Foundation.
   4  *  Modifications Copyright (C) 2020-2021 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.models.pdp.persistence.provider;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26
  27 import java.time.Instant;
  28 import java.util.ArrayList;
  29 import java.util.Collections;
  30 import java.util.List;
  31 import java.util.Properties;
  32 import org.eclipse.persistence.config.PersistenceUnitProperties;
  33 import org.junit.After;
  34 import org.junit.Before;
  35 import org.junit.Test;
  36 import org.onap.policy.models.base.Validated;
  37 import org.onap.policy.models.dao.DaoParameters;
  38 import org.onap.policy.models.dao.PfDao;
  39 import org.onap.policy.models.dao.PfDaoFactory;
  40 import org.onap.policy.models.dao.impl.DefaultPfDao;
  41 import org.onap.policy.models.pdp.concepts.PdpEngineWorkerStatistics;
  42 import org.onap.policy.models.pdp.concepts.PdpStatistics;
  43
  44 public class PdpStatisticsProviderTest {
  45     private static final String DAO_IS_NULL = "dao is marked .*ull but is null";
  46     private static final String LIST_IS_NULL = "pdpStatisticsList is marked .*ull but is null";
  47     private static final String GROUP0 = "group0";
  48     private static final String NAME = "name";
  49     private static final String GROUP = "group";
  50     private static final String SUBGROUP = "subgroup";
  51     private static final Instant TIMESTAMP1 = Instant.ofEpochSecond(1078884319);
  52     private static final Instant TIMESTAMP2 = Instant.ofEpochSecond(1078884350);
  53
  54     private PfDao pfDao;
  55
  56     private List<PdpEngineWorkerStatistics> engineStats = new ArrayList<>();
  57     private PdpStatistics pdpStatistics11;
  58     private PdpStatistics pdpStatistics12;
  59     private PdpStatistics pdpStatistics22;
  60     private PdpStatistics pdpStatistics31;
  61
  62     // checkstyle complained about this as a local variable; had to make it a field
  63     private long genId;
  64
  65     /**
  66      * Set up test Dao.
  67      */
  68     @Before
  69     public void setupDao() throws Exception {
  70         final DaoParameters daoParameters = new DaoParameters();
  71         daoParameters.setPluginClass(DefaultPfDao.class.getName());
  72
  73         daoParameters.setPersistenceUnit("ToscaConceptTest");
  74
  75         Properties jdbcProperties = new Properties();
  76         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "policy");
  77         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "P01icY");
  78
  79         if (System.getProperty("USE-MARIADB") != null) {
  80             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.mariadb.jdbc.Driver");
  81             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:mariadb://localhost:3306/policy");
  82         } else {
  83             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
  84             jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:PdpStatisticsProviderTest");
  85         }
  86
  87         daoParameters.setJdbcProperties(jdbcProperties);
  88
  89         pfDao = new PfDaoFactory().createPfDao(daoParameters);
  90         pfDao.init(daoParameters);
  91
  92         genId = 1;
  93
  94         pdpStatistics11 = new PdpStatistics();
  95         pdpStatistics11.setPdpInstanceId(NAME);
  96         pdpStatistics11.setTimeStamp(TIMESTAMP1);
  97         pdpStatistics11.setGeneratedId(genId++);
  98         pdpStatistics11.setPdpGroupName(GROUP);
  99         pdpStatistics11.setPdpSubGroupName(SUBGROUP);
 100         pdpStatistics11.setPolicyDeployCount(2);
 101         pdpStatistics11.setPolicyDeployFailCount(1);
 102         pdpStatistics11.setPolicyDeploySuccessCount(1);
 103         pdpStatistics11.setPolicyExecutedCount(2);
 104         pdpStatistics11.setPolicyExecutedFailCount(1);
 105         pdpStatistics11.setPolicyExecutedSuccessCount(1);
 106         pdpStatistics11.setEngineStats(engineStats);
 107
 108         pdpStatistics12 = new PdpStatistics();
 109         pdpStatistics12.setPdpInstanceId(NAME);
 110         pdpStatistics12.setTimeStamp(TIMESTAMP2);
 111         pdpStatistics12.setGeneratedId(genId++);
 112         pdpStatistics12.setPdpGroupName(GROUP);
 113         pdpStatistics12.setPdpSubGroupName(SUBGROUP);
 114         pdpStatistics12.setPolicyDeployCount(2);
 115         pdpStatistics12.setPolicyDeployFailCount(1);
 116         pdpStatistics12.setPolicyDeploySuccessCount(1);
 117         pdpStatistics12.setPolicyExecutedCount(2);
 118         pdpStatistics12.setPolicyExecutedFailCount(1);
 119         pdpStatistics12.setPolicyExecutedSuccessCount(1);
 120         pdpStatistics12.setEngineStats(engineStats);
 121
 122         pdpStatistics22 = new PdpStatistics();
 123         pdpStatistics22.setPdpInstanceId("name2");
 124         pdpStatistics22.setTimeStamp(TIMESTAMP2);
 125         pdpStatistics22.setGeneratedId(genId++);
 126         pdpStatistics22.setPdpGroupName(GROUP);
 127         pdpStatistics22.setPdpSubGroupName(SUBGROUP);
 128         pdpStatistics22.setPolicyDeployCount(2);
 129         pdpStatistics22.setPolicyDeployFailCount(1);
 130         pdpStatistics22.setPolicyDeploySuccessCount(1);
 131         pdpStatistics22.setPolicyExecutedCount(2);
 132         pdpStatistics22.setPolicyExecutedFailCount(1);
 133         pdpStatistics22.setPolicyExecutedSuccessCount(1);
 134         pdpStatistics22.setEngineStats(engineStats);
 135
 136         pdpStatistics31 = new PdpStatistics();
 137         pdpStatistics31.setPdpInstanceId("name3");
 138         pdpStatistics31.setTimeStamp(TIMESTAMP1);
 139         pdpStatistics31.setGeneratedId(genId++);
 140         pdpStatistics31.setPdpGroupName(GROUP);
 141         pdpStatistics31.setPdpSubGroupName(SUBGROUP);
 142         pdpStatistics31.setPolicyDeployCount(2);
 143         pdpStatistics31.setPolicyDeployFailCount(1);
 144         pdpStatistics31.setPolicyDeploySuccessCount(1);
 145         pdpStatistics31.setPolicyExecutedCount(2);
 146         pdpStatistics31.setPolicyExecutedFailCount(1);
 147         pdpStatistics31.setPolicyExecutedSuccessCount(1);
 148         pdpStatistics31.setEngineStats(engineStats);
 149
 150         List<PdpStatistics> create = List.of(pdpStatistics11, pdpStatistics22, pdpStatistics31, pdpStatistics12);
 151         List<PdpStatistics> createdPdpStatisticsList = new PdpStatisticsProvider().createPdpStatistics(pfDao, create);
 152
 153         // these should match AND be in the same order
 154         assertThat(createdPdpStatisticsList).isEqualTo(create);
 155     }
 156
 157     @After
 158     public void teardown() {
 159         pfDao.close();
 160     }
 161
 162     @Test
 163     public void testNotOkPdpStatistics() {
 164         PdpStatistics pdpStatisticsErr = new PdpStatistics();
 165         pdpStatisticsErr.setPdpInstanceId("NULL");
 166         pdpStatisticsErr.setPdpGroupName(GROUP);
 167         ArrayList<PdpStatistics> pdpStatisticsNullList = new ArrayList<>();
 168         pdpStatisticsNullList.add(pdpStatisticsErr);
 169
 170         assertThatThrownBy(() -> {
 171             new PdpStatisticsProvider().createPdpStatistics(pfDao, null);
 172         }).hasMessageMatching(LIST_IS_NULL);
 173
 174         assertThatThrownBy(() -> {
 175             new PdpStatisticsProvider().updatePdpStatistics(pfDao, null);
 176         }).hasMessageMatching(LIST_IS_NULL);
 177
 178         assertThatThrownBy(() -> {
 179             new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsNullList);
 180         }).hasMessageContaining("pdp statistics").hasMessageContaining("key")
 181                         .hasMessageContaining(Validated.IS_A_NULL_KEY);
 182
 183         assertThatThrownBy(() -> {
 184             new PdpStatisticsProvider().updatePdpStatistics(pfDao, pdpStatisticsNullList);
 185         }).hasMessageContaining("pdp statistics").hasMessageContaining("key")
 186                         .hasMessageContaining(Validated.IS_A_NULL_KEY);
 187     }
 188
 189     @Test
 190     public void testGetFilteredPdpStatistics() throws Exception {
 191
 192         assertThatThrownBy(() -> {
 193             new PdpStatisticsProvider().getFilteredPdpStatistics(null, PdpFilterParameters.builder().build());
 194         }).hasMessageMatching(DAO_IS_NULL);
 195
 196         List<PdpStatistics> getPdpStatisticsList;
 197
 198         // match on name - returns multiple records
 199         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 200                         .builder().name(NAME).group(GROUP).startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 201         verifyEquals(getPdpStatisticsList, List.of(pdpStatistics11, pdpStatistics12));
 202
 203         // this name only has one record
 204         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 205                         .builder().name("name2").group(GROUP).startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 206         verifyEquals(getPdpStatisticsList, List.of(pdpStatistics22));
 207
 208         // match on subgroup
 209         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao,
 210                         PdpFilterParameters.builder().name("name2").group(GROUP).subGroup(SUBGROUP)
 211                                         .startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 212         verifyEquals(getPdpStatisticsList, List.of(pdpStatistics22));
 213
 214         // only request one record
 215         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 216                         .builder().name(NAME).recordNum(1).build());
 217         verifyEquals(getPdpStatisticsList, List.of(pdpStatistics12));
 218
 219         // request too many records
 220         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 221                         .builder().name(NAME).recordNum(10000).build());
 222         verifyEquals(getPdpStatisticsList, List.of(pdpStatistics11, pdpStatistics12));
 223
 224         // group mismatch
 225         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 226                         .builder().name(NAME).group(GROUP0).startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 227         assertThat(getPdpStatisticsList).isEmpty();
 228
 229         // subgroup mismatch
 230         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao,
 231                         PdpFilterParameters.builder().name("name2").group(GROUP).subGroup("subgroup2")
 232                                         .startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 233         assertThat(getPdpStatisticsList).isEmpty();
 234     }
 235
 236     @Test
 237     public void testUpdatePdpStatistics() throws Exception {
 238         assertThatThrownBy(() -> {
 239             new PdpStatisticsProvider().updatePdpStatistics(null, null);
 240         }).hasMessageMatching(DAO_IS_NULL);
 241
 242         pdpStatistics11.setPdpGroupName(GROUP0);
 243         List<PdpStatistics> update = List.of(pdpStatistics11);
 244         List<PdpStatistics> updatePdpStatisticsList = new PdpStatisticsProvider().updatePdpStatistics(pfDao, update);
 245
 246         // these should match AND be in the same order
 247         assertThat(updatePdpStatisticsList).isEqualTo(update);
 248     }
 249
 250     @Test
 251     public void testDeletePdpStatistics() throws Exception {
 252         assertThatThrownBy(() -> {
 253             new PdpStatisticsProvider().deletePdpStatistics(null, null, null);
 254         }).hasMessageMatching(DAO_IS_NULL);
 255
 256         assertThatThrownBy(() -> {
 257             new PdpStatisticsProvider().deletePdpStatistics(pfDao, null, null);
 258         }).hasMessageMatching("name is marked .*ull but is null");
 259
 260         List<PdpStatistics> deletedPdpStatisticsList =
 261                 new PdpStatisticsProvider().deletePdpStatistics(pfDao, NAME, null);
 262         verifyEquals(deletedPdpStatisticsList, List.of(pdpStatistics12, pdpStatistics11));
 263     }
 264
 265     private void verifyEquals(List<PdpStatistics> list1, List<PdpStatistics> list2) {
 266         assertThat(sort(list1)).isEqualTo(sort(list2));
 267     }
 268
 269     private List<PdpStatistics> sort(List<PdpStatistics> list1) {
 270         List<PdpStatistics> list2 = new ArrayList<>(list1);
 271         Collections.sort(list2, (stat1, stat2) -> stat1.getGeneratedId().compareTo(stat2.getGeneratedId()));
 272
 273         return list2;
 274     }
 275 }