ONAP-PAP-REST/src/test/java/org/onap/policy/pap/ia/DbAuditCompareEntriesTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017, 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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.ia;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertTrue;
  25
  26 import java.util.Date;
  27 import java.util.HashMap;
  28 import java.util.Properties;
  29 import java.util.Set;
  30
  31 import javax.persistence.EntityManager;
  32 import javax.persistence.EntityManagerFactory;
  33 import javax.persistence.EntityTransaction;
  34 import javax.persistence.Persistence;
  35
  36 import org.apache.commons.lang3.SerializationUtils;
  37 import org.apache.commons.logging.Log;
  38 import org.apache.commons.logging.LogFactory;
  39 import org.junit.After;
  40 import org.junit.Before;
  41 import org.junit.Test;
  42 import org.onap.policy.common.ia.DbAudit;
  43 import org.onap.policy.common.ia.DbDao;
  44 import org.onap.policy.common.ia.IntegrityAuditProperties;
  45 import org.onap.policy.common.ia.jpa.IntegrityAuditEntity;
  46 import org.onap.policy.common.im.jpa.ForwardProgressEntity;
  47 import org.onap.policy.common.im.jpa.ResourceRegistrationEntity;
  48 import org.onap.policy.common.im.jpa.StateManagementEntity;
  49 import org.onap.policy.jpa.BackUpMonitorEntity;
  50
  51 public class DbAuditCompareEntriesTest {
  52
  53     private static Log logger = LogFactory.getLog(DbAuditCompareEntriesTest.class);
  54     private DbDao dbDAO;
  55     private String persistenceUnit;
  56     private Properties properties;
  57     private String resourceName;
  58     private String dbDriver;
  59     private String dbUrl;
  60     private String dbUser;
  61     private String dbPwd;
  62     private String siteName;
  63     private String nodeType;
  64     private static final String DEFAULT_DB_DRIVER = "org.h2.Driver";
  65     private static final String DEFAULT_DB_USER = "sa";
  66     private static final String DEFAULT_DB_PWD = "";
  67
  68     @Before
  69     public void setUp() throws Exception {
  70         logger.info("setUp: Entering");
  71
  72         properties = new Properties();
  73         properties.put(IntegrityAuditProperties.DB_DRIVER, DbAuditCompareEntriesTest.DEFAULT_DB_DRIVER);
  74         properties.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/xacmlTest");
  75         properties.put(IntegrityAuditProperties.DB_USER, DbAuditCompareEntriesTest.DEFAULT_DB_USER);
  76         properties.put(IntegrityAuditProperties.DB_PWD, DbAuditCompareEntriesTest.DEFAULT_DB_PWD);
  77         properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
  78         properties.put(IntegrityAuditProperties.NODE_TYPE, "pap");
  79
  80         dbDriver = DbAuditCompareEntriesTest.DEFAULT_DB_DRIVER;
  81         dbUrl = "jdbc:h2:file:./sql/xacmlTest";
  82         dbUser = DbAuditCompareEntriesTest.DEFAULT_DB_USER;
  83         dbPwd = DbAuditCompareEntriesTest.DEFAULT_DB_PWD;
  84         siteName = "SiteA";
  85         nodeType = "pap";
  86         persistenceUnit = "testPapPU";
  87         resourceName = "siteA.pap1";
  88
  89         // Clean the iaTest DB table for IntegrityAuditEntity entries
  90         cleanDb(persistenceUnit, properties);
  91
  92         logger.info("setUp: Exiting");
  93     }
  94
  95     @After
  96     public void tearDown() throws Exception {
  97         logger.info("tearDown: Entering");
  98         // nothing to do
  99         logger.info("tearDown: Exiting");
 100     }
 101
 102     public void cleanDb(String persistenceUnit, Properties properties) {
 103         logger.debug("cleanDb: enter");
 104
 105         EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
 106
 107         EntityManager em = emf.createEntityManager();
 108         // Start a transaction
 109         EntityTransaction et = em.getTransaction();
 110
 111         et.begin();
 112
 113         // Clean up the DB
 114         em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
 115
 116         // commit transaction
 117         et.commit();
 118         em.close();
 119         logger.debug("cleanDb: exit");
 120     }
 121
 122     /*
 123      * Tests that a comparison between hashsets is successful if
 124      * the entries match
 125      */
 126     @Test
 127     public void runAllTests() throws Exception {
 128         logger.info("runAllTests: Entering");
 129
 130         testIntegrityAuditEntity();
 131         testBackupMonitorEntity();
 132         testStateManagementEntity();
 133         testForwardProgressEntity();
 134         testResourceRegistrationEntity();
 135
 136         // clean up the IntegrityAuditEntity table
 137         cleanDb(persistenceUnit, properties);
 138
 139         logger.info("runAllTests: Exit");
 140     }
 141
 142     public void testIntegrityAuditEntity() throws Exception {
 143         logger.info("testIntegrityAuditEntity: Entering");
 144
 145         dbDAO = new DbDao(resourceName, persistenceUnit, properties);
 146         DbAudit dbAudit = new DbAudit(dbDAO);
 147
 148         String className = null;
 149         // There is only one entry IntegrityAuditEntity, but we will check anyway
 150         Set<String> classNameSet = dbDAO.getPersistenceClassNames();
 151         for (String c : classNameSet) {
 152             if (c.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")) {
 153                 className = c;
 154             }
 155         }
 156         String resourceName1 = resourceName;
 157         String resourceName2 = resourceName;
 158
 159         IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
 160         IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
 161         Date date = new Date();
 162
 163         /*
 164          * Two entries with the same field values
 165          */
 166         entry1.setDesignated(false);
 167         entry1.setJdbcDriver(dbDriver);
 168         entry1.setJdbcPassword(dbPwd);
 169         entry1.setJdbcUrl(dbUrl);
 170         entry1.setJdbcUser(dbUser);
 171         entry1.setLastUpdated(date);
 172         entry1.setNodeType(nodeType);
 173         entry1.setPersistenceUnit(persistenceUnit);
 174         entry1.setResourceName(resourceName1);
 175         entry1.setSite(siteName);
 176
 177         entry2 = SerializationUtils.clone(entry1);
 178
 179         dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
 180
 181         HashMap<Object, Object> myEntries = new HashMap<>();
 182         HashMap<Object, Object> theirEntries = new HashMap<>();
 183
 184         myEntries.put("pdp1", entry1);
 185         theirEntries.put("pdp1", entry2);
 186
 187         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 188
 189         /*
 190          * Assert that there are no mismatches returned
 191          */
 192         assertTrue(result.isEmpty());
 193
 194         /*
 195          * ************************************
 196          * Now test with a mis-matched entry
 197          * ************************************
 198          */
 199
 200         /*
 201          * Change the entry2 to different designated value
 202          */
 203         entry2.setDesignated(true);
 204
 205         myEntries = new HashMap<>();
 206         theirEntries = new HashMap<>();
 207
 208         myEntries.put("pdp1", entry1);
 209         theirEntries.put("pdp1", entry2);
 210
 211         result = dbAudit.compareEntries(myEntries, theirEntries);
 212
 213         /*
 214          * Assert that there was one mismatch
 215          */
 216         assertEquals(1, result.size());
 217         logger.info("testIntegrityAuditEntity: Exit");
 218     }
 219
 220     void testBackupMonitorEntity() throws Exception {
 221         logger.info("testBackupMonitorEntity: Entering");
 222
 223         dbDAO = new DbDao(resourceName, persistenceUnit, properties);
 224         DbAudit dbAudit = new DbAudit(dbDAO);
 225
 226         BackUpMonitorEntity entry1 = new BackUpMonitorEntity();
 227         BackUpMonitorEntity entry2 = new BackUpMonitorEntity();
 228
 229         // Two entries with the same field values
 230
 231         entry1.setFlag("flag1");
 232         entry1.setResourceNodeName("node1");
 233         entry1.setResourceName("resourceName");
 234         entry1.setTimeStamp(new Date());
 235
 236         // Clone the first entry
 237         entry2 = SerializationUtils.clone(entry1);
 238
 239         HashMap<Object, Object> myEntries = new HashMap<>();
 240         HashMap<Object, Object> theirEntries = new HashMap<>();
 241
 242         myEntries.put("pdp1", entry1);
 243         theirEntries.put("pdp1", entry2);
 244
 245         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 246
 247         // Assert that there are no mismatches returned
 248
 249         assertTrue(result.isEmpty());
 250
 251         /*
 252          * ************************************
 253          * Now test with a mis-matched entry
 254          ************************************/
 255
 256         // Change a field on entry2
 257
 258         entry2.setFlag("flag2");
 259
 260         myEntries = new HashMap<>();
 261         theirEntries = new HashMap<>();
 262
 263         myEntries.put("pdp1", entry1);
 264         theirEntries.put("pdp1", entry2);
 265
 266         result = dbAudit.compareEntries(myEntries, theirEntries);
 267
 268         // Assert that there was one mismatch
 269
 270         assertEquals(1, result.size());
 271         logger.info("testBackupMonitorEntity: Exit");
 272     }
 273
 274     void testStateManagementEntity() throws Exception {
 275         logger.info("testStateManagementEntity: Entering");
 276
 277         dbDAO = new DbDao(resourceName, persistenceUnit, properties);
 278         DbAudit dbAudit = new DbAudit(dbDAO);
 279
 280         StateManagementEntity entry1 = new StateManagementEntity();
 281         StateManagementEntity entry2 = new StateManagementEntity();
 282
 283         // Two entries with the same field values
 284
 285         entry1.setAdminState("locked");
 286         entry1.setAvailStatus("null");
 287         entry1.setModifiedDate(new Date());
 288         entry1.setOpState("enabled");
 289         entry1.setResourceName("myResource");
 290         entry1.setStandbyStatus("coldstandby");
 291
 292         // Clone the first entry
 293         entry2 = SerializationUtils.clone(entry1);
 294
 295         HashMap<Object, Object> myEntries = new HashMap<>();
 296         HashMap<Object, Object> theirEntries = new HashMap<>();
 297
 298         myEntries.put("pdp1", entry1);
 299         theirEntries.put("pdp1", entry2);
 300
 301         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 302
 303         // Assert that there are no mismatches returned
 304
 305         assertTrue(result.isEmpty());
 306
 307         /*
 308          * ************************************
 309          * Now test with a mis-matched entry
 310          ************************************/
 311
 312         // Change a field on entry2
 313
 314         entry2.setAdminState("unlocked");
 315
 316         myEntries = new HashMap<>();
 317         theirEntries = new HashMap<>();
 318
 319         myEntries.put("pdp1", entry1);
 320         theirEntries.put("pdp1", entry2);
 321
 322         result = dbAudit.compareEntries(myEntries, theirEntries);
 323
 324         // Assert that there was one mismatch
 325
 326         assertEquals(1, result.size());
 327         logger.info("testStateManagementEntity: Exit");
 328     }
 329
 330     void testForwardProgressEntity() throws Exception {
 331         logger.info("testForwardProgressEntity: Entering");
 332
 333         dbDAO = new DbDao(resourceName, persistenceUnit, properties);
 334         DbAudit dbAudit = new DbAudit(dbDAO);
 335
 336         ForwardProgressEntity entry1 = new ForwardProgressEntity();
 337         ForwardProgressEntity entry2 = new ForwardProgressEntity();
 338
 339         // Two entries with the same field values
 340
 341         entry1.setFpcCount(123L);
 342         entry1.setLastUpdated(new Date());
 343         entry1.setResourceName("myResource");
 344
 345         // Clone the first entry
 346         entry2 = SerializationUtils.clone(entry1);
 347
 348         HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 349         HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 350
 351         myEntries.put("pdp1", entry1);
 352         theirEntries.put("pdp1", entry2);
 353
 354         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 355
 356         // Assert that there are no mismatches returned
 357
 358         assertTrue(result.isEmpty());
 359
 360         /*
 361          * ************************************
 362          * Now test with a mis-matched entry
 363          ************************************/
 364
 365         // Change a field on entry2
 366
 367         entry2.setFpcCount(321L);
 368
 369         myEntries = new HashMap<>();
 370         theirEntries = new HashMap<>();
 371
 372         myEntries.put("pdp1", entry1);
 373         theirEntries.put("pdp1", entry2);
 374
 375         result = dbAudit.compareEntries(myEntries, theirEntries);
 376
 377         // Assert that there was one mismatch
 378
 379         assertEquals(1, result.size());
 380         logger.info("testForwardProgressEntity: Exit");
 381     }
 382
 383     void testResourceRegistrationEntity() throws Exception {
 384         logger.info("testResourceRegistrationEntity: Entering");
 385
 386         dbDAO = new DbDao(resourceName, persistenceUnit, properties);
 387         DbAudit dbAudit = new DbAudit(dbDAO);
 388
 389         ResourceRegistrationEntity entry1 = new ResourceRegistrationEntity();
 390         ResourceRegistrationEntity entry2 = new ResourceRegistrationEntity();
 391
 392         // Two entries with the same field values
 393
 394         entry1.setNodeType("pap");
 395         entry1.setLastUpdated(new Date());
 396         entry1.setResourceName("myResource");
 397         entry1.setResourceUrl("http://nowhere.com");
 398         entry1.setSite("site_1");
 399
 400         // Clone the first entry
 401         entry2 = SerializationUtils.clone(entry1);
 402
 403         HashMap<Object, Object> myEntries = new HashMap<>();
 404         HashMap<Object, Object> theirEntries = new HashMap<>();
 405
 406         myEntries.put("pdp1", entry1);
 407         theirEntries.put("pdp1", entry2);
 408
 409         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 410
 411         // Assert that there are no mismatches returned
 412
 413         assertTrue(result.isEmpty());
 414
 415         /*
 416          * ************************************
 417          * Now test with a mis-matched entry
 418          ************************************/
 419
 420         // Change a field on entry2
 421
 422         entry2.setSite("site_1a");
 423
 424         myEntries = new HashMap<>();
 425         theirEntries = new HashMap<>();
 426
 427         myEntries.put("pdp1", entry1);
 428         theirEntries.put("pdp1", entry2);
 429
 430         result = dbAudit.compareEntries(myEntries, theirEntries);
 431
 432         // Assert that there was one mismatch
 433
 434         assertEquals(1, result.size());
 435         logger.info("testResourceRegistrationEntity: Exit");
 436     }
 437 }