gerrit.onap Code Review - policy/models.git/blob

   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 import static org.junit.Assert.assertEquals;
  27
  28 import java.time.Instant;
  29 import java.util.ArrayList;
  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     private static final Long GENERATEDID1 = 1L;
  54     private static final Long GENERATEDID2 = 2L;
  55     private static final String ORDER = "DESC";
  56
  57     private PfDao pfDao;
  58
  59     private ArrayList<PdpStatistics> pdpStatisticsTestList = new ArrayList<>();
  60     private List<PdpEngineWorkerStatistics> engineStats = new ArrayList<>();
  61     private String testListStr;
  62     private String name1ListStr;
  63     private String createdListStr;
  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         PdpStatistics pdpStatistics = new PdpStatistics();
  93         pdpStatistics.setPdpInstanceId(NAME);
  94         pdpStatistics.setTimeStamp(TIMESTAMP1);
  95         pdpStatistics.setGeneratedId(GENERATEDID1);
  96         pdpStatistics.setPdpGroupName(GROUP);
  97         pdpStatistics.setPdpSubGroupName(SUBGROUP);
  98         pdpStatistics.setPolicyDeployCount(2);
  99         pdpStatistics.setPolicyDeployFailCount(1);
 100         pdpStatistics.setPolicyDeploySuccessCount(1);
 101         pdpStatistics.setPolicyExecutedCount(2);
 102         pdpStatistics.setPolicyExecutedFailCount(1);
 103         pdpStatistics.setPolicyExecutedSuccessCount(1);
 104         pdpStatistics.setEngineStats(engineStats);
 105         pdpStatisticsTestList.add(pdpStatistics);
 106         name1ListStr = pdpStatisticsTestList.toString();
 107
 108         PdpStatistics pdpStatistics2 = new PdpStatistics();
 109         pdpStatistics2.setPdpInstanceId("name2");
 110         pdpStatistics2.setTimeStamp(TIMESTAMP2);
 111         pdpStatistics2.setGeneratedId(GENERATEDID2);
 112         pdpStatistics2.setPdpGroupName(GROUP);
 113         pdpStatistics2.setPdpSubGroupName(SUBGROUP);
 114         pdpStatistics2.setPolicyDeployCount(2);
 115         pdpStatistics2.setPolicyDeployFailCount(1);
 116         pdpStatistics2.setPolicyDeploySuccessCount(1);
 117         pdpStatistics2.setPolicyExecutedCount(2);
 118         pdpStatistics2.setPolicyExecutedFailCount(1);
 119         pdpStatistics2.setPolicyExecutedSuccessCount(1);
 120         pdpStatistics2.setEngineStats(engineStats);
 121         pdpStatisticsTestList.add(pdpStatistics2);
 122         testListStr = pdpStatisticsTestList.toString();
 123
 124         List<PdpStatistics> createdPdpStatisticsList;
 125         createdPdpStatisticsList = new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsTestList);
 126         createdListStr = createdPdpStatisticsList.toString();
 127         assertEquals(createdListStr.replaceAll("\\s+", ""), testListStr.replaceAll("\\s+", ""));
 128     }
 129
 130     @After
 131     public void teardown() {
 132         pfDao.close();
 133     }
 134
 135     @Test
 136     public void testNotOkPdpStatistics() {
 137         PdpStatistics pdpStatisticsErr = new PdpStatistics();
 138         pdpStatisticsErr.setPdpInstanceId("NULL");
 139         pdpStatisticsErr.setPdpGroupName(GROUP);
 140         ArrayList<PdpStatistics> pdpStatisticsNullList = new ArrayList<>();
 141         pdpStatisticsNullList.add(pdpStatisticsErr);
 142
 143         assertThatThrownBy(() -> {
 144             new PdpStatisticsProvider().createPdpStatistics(pfDao, null);
 145         }).hasMessageMatching(LIST_IS_NULL);
 146
 147         assertThatThrownBy(() -> {
 148             new PdpStatisticsProvider().updatePdpStatistics(pfDao, null);
 149         }).hasMessageMatching(LIST_IS_NULL);
 150
 151         assertThatThrownBy(() -> {
 152             new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsNullList);
 153         }).hasMessageContaining("pdp statistics").hasMessageContaining("key")
 154                         .hasMessageContaining(Validated.IS_A_NULL_KEY);
 155
 156         assertThatThrownBy(() -> {
 157             new PdpStatisticsProvider().updatePdpStatistics(pfDao, pdpStatisticsNullList);
 158         }).hasMessageContaining("pdp statistics").hasMessageContaining("key")
 159                         .hasMessageContaining(Validated.IS_A_NULL_KEY);
 160     }
 161
 162     @Test
 163     public void testGetPdpStatistics() throws Exception {
 164         assertThatThrownBy(() -> {
 165             new PdpStatisticsProvider().createPdpStatistics(null, null);
 166         }).hasMessageMatching(DAO_IS_NULL);
 167         assertThatThrownBy(() -> {
 168             new PdpStatisticsProvider().getPdpStatistics(null, null, null);
 169         }).hasMessageMatching(DAO_IS_NULL);
 170
 171         List<PdpStatistics> getPdpStatisticsList;
 172         getPdpStatisticsList = new PdpStatisticsProvider().getPdpStatistics(pfDao, NAME, TIMESTAMP1);
 173         assertThat(getPdpStatisticsList).hasSize(1);
 174         String gotListStr = getPdpStatisticsList.toString();
 175         assertEquals(name1ListStr.replaceAll("\\s+", ""), gotListStr.replaceAll("\\s+", ""));
 176
 177         // name is null
 178         getPdpStatisticsList = new PdpStatisticsProvider().getPdpStatistics(pfDao, null, TIMESTAMP1);
 179         gotListStr = getPdpStatisticsList.toString();
 180         assertEquals(testListStr.replaceAll("\\s+", ""), gotListStr.replaceAll("\\s+", ""));
 181     }
 182
 183     @Test
 184     public void testGetFilteredPdpStatisticsOld() throws Exception {
 185         assertThatThrownBy(() -> {
 186             new PdpStatisticsProvider().getFilteredPdpStatistics(null, NAME, GROUP, SUBGROUP, TIMESTAMP1, TIMESTAMP2,
 187                     ORDER, 1);
 188         }).hasMessageMatching(DAO_IS_NULL);
 189
 190         assertThatThrownBy(() -> {
 191             new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, NAME, null, null, TIMESTAMP1, TIMESTAMP2, ORDER,
 192                     1);
 193         }).hasMessageMatching("pdpGroupName is marked .*ull but is null");
 194
 195
 196         List<PdpStatistics> createdPdpStatisticsList;
 197         createdPdpStatisticsList = new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsTestList);
 198         createdListStr = createdPdpStatisticsList.toString();
 199         assertEquals(createdListStr.replaceAll("\\s+", ""), testListStr.replaceAll("\\s+", ""));
 200
 201         List<PdpStatistics> getPdpStatisticsList;
 202         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, NAME, GROUP, null,
 203                 TIMESTAMP1, TIMESTAMP2, ORDER, 0);
 204         assertThat(getPdpStatisticsList).hasSize(1);
 205         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, "name2", GROUP, null,
 206                 TIMESTAMP1, TIMESTAMP2, ORDER, 0);
 207         assertThat(getPdpStatisticsList).hasSize(1);
 208         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, "name2", GROUP, SUBGROUP,
 209                 TIMESTAMP1, TIMESTAMP2, ORDER, 0);
 210         assertThat(getPdpStatisticsList).hasSize(1);
 211     }
 212
 213     @Test
 214     public void testGetFilteredPdpStatistics() throws Exception {
 215
 216         assertThatThrownBy(() -> {
 217             new PdpStatisticsProvider().getFilteredPdpStatistics(null, PdpFilterParameters.builder().build());
 218         }).hasMessageMatching(DAO_IS_NULL);
 219
 220
 221         List<PdpStatistics> createdPdpStatisticsList;
 222         createdPdpStatisticsList = new PdpStatisticsProvider().createPdpStatistics(pfDao, pdpStatisticsTestList);
 223         createdListStr = createdPdpStatisticsList.toString();
 224         assertEquals(createdListStr.replaceAll("\\s+", ""), testListStr.replaceAll("\\s+", ""));
 225
 226         List<PdpStatistics> getPdpStatisticsList;
 227         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 228                         .builder().name(NAME).group(GROUP).startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 229         assertThat(getPdpStatisticsList).hasSize(1);
 230         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao, PdpFilterParameters
 231                         .builder().name("name2").group(GROUP).startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 232         assertThat(getPdpStatisticsList).hasSize(1);
 233         getPdpStatisticsList = new PdpStatisticsProvider().getFilteredPdpStatistics(pfDao,
 234                         PdpFilterParameters.builder().name("name2").group(GROUP).subGroup(SUBGROUP)
 235                                         .startTime(TIMESTAMP1).endTime(TIMESTAMP2).build());
 236         assertThat(getPdpStatisticsList).hasSize(1);
 237     }
 238
 239     @Test
 240     public void testUpdatePdpStatistics() throws Exception {
 241         assertThatThrownBy(() -> {
 242             new PdpStatisticsProvider().updatePdpStatistics(null, null);
 243         }).hasMessageMatching(DAO_IS_NULL);
 244
 245         pdpStatisticsTestList.get(0).setPdpGroupName(GROUP0);
 246         testListStr = pdpStatisticsTestList.toString();
 247         List<PdpStatistics> updatePdpStatisticsList =
 248                 new PdpStatisticsProvider().updatePdpStatistics(pfDao, pdpStatisticsTestList);
 249         String gotListStr = updatePdpStatisticsList.toString();
 250         assertEquals(testListStr.replaceAll("\\s+", ""), gotListStr.replaceAll("\\s+", ""));
 251     }
 252
 253     @Test
 254     public void testDeletePdpStatistics() throws Exception {
 255         assertThatThrownBy(() -> {
 256             new PdpStatisticsProvider().deletePdpStatistics(null, null, null);
 257         }).hasMessageMatching(DAO_IS_NULL);
 258
 259         assertThatThrownBy(() -> {
 260             new PdpStatisticsProvider().deletePdpStatistics(pfDao, null, null);
 261         }).hasMessageMatching("name is marked .*ull but is null");
 262
 263         List<PdpStatistics> deletedPdpStatisticsList =
 264                 new PdpStatisticsProvider().deletePdpStatistics(pfDao, NAME, null);
 265         String gotListStr = deletedPdpStatisticsList.toString();
 266         assertEquals(name1ListStr.replaceAll("\\s+", ""), gotListStr.replaceAll("\\s+", ""));
 267     }
 268
 269 }