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 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     /*
 124      * Tests that a comparison between hashsets is successful if
 125      * the entries match
 126      */
 127     @Test
 128     public void runAllTests() throws Exception {
 129         logger.info("runAllTests: Entering");
 130
 131
 132         testIntegrityAuditEntity();
 133         testBackupMonitorEntity();
 134         testStateManagementEntity();
 135         testForwardProgressEntity();
 136         testResourceRegistrationEntity();
 137
 138         //clean up the IntegrityAuditEntity table
 139         cleanDb(persistenceUnit, properties);
 140
 141         logger.info("runAllTests: Exit");
 142     }
 143
 144
 145     public void testIntegrityAuditEntity() throws Exception {
 146         logger.info("testIntegrityAuditEntity: Entering");
 147
 148         dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 149         DbAudit dbAudit = new DbAudit(dbDAO);
 150
 151         String className = null;
 152         //There is only one entry IntegrityAuditEntity, but we will check anyway
 153         Set<String> classNameSet = dbDAO.getPersistenceClassNames();
 154         for(String c : classNameSet){
 155             if (c.equals("org.onap.policy.common.ia.jpa.IntegrityAuditEntity")){
 156                 className = c;
 157             }
 158         }
 159         String resourceName1 = resourceName;
 160         String resourceName2 = resourceName;
 161
 162         IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
 163         IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
 164         Date date = new Date();
 165
 166         /*
 167          * Two entries with the same field values
 168          */
 169         entry1.setDesignated(false);
 170         entry1.setJdbcDriver(dbDriver);
 171         entry1.setJdbcPassword(dbPwd);
 172         entry1.setJdbcUrl(dbUrl);
 173         entry1.setJdbcUser(dbUser);
 174         entry1.setLastUpdated(date);
 175         entry1.setNodeType(nodeType);
 176         entry1.setPersistenceUnit(persistenceUnit);
 177         entry1.setResourceName(resourceName1);
 178         entry1.setSite(siteName);
 179
 180         entry2 = SerializationUtils.clone(entry1);
 181
 182         dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
 183
 184         HashMap<Object, Object> myEntries = new HashMap<>();
 185         HashMap<Object, Object> theirEntries = new HashMap<>();
 186
 187         myEntries.put("pdp1", entry1);
 188         theirEntries.put("pdp1", entry2);
 189
 190         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 191
 192         /*
 193          * Assert that there are no mismatches returned
 194          */
 195         assertTrue(result.isEmpty());
 196
 197         /*
 198          * ************************************
 199          * Now test with a mis-matched entry
 200          * ************************************
 201          */
 202
 203         /*
 204          * Change the entry2 to different designated value
 205          */
 206         entry2.setDesignated(true);
 207
 208         myEntries = new HashMap<>();
 209         theirEntries = new HashMap<>();
 210
 211         myEntries.put("pdp1", entry1);
 212         theirEntries.put("pdp1", entry2);
 213
 214         result = dbAudit.compareEntries(myEntries, theirEntries);
 215
 216         /*
 217          * Assert that there was one mismatch
 218          */
 219         assertEquals(1, result.size());
 220         logger.info("testIntegrityAuditEntity: Exit");
 221     }
 222
 223     void testBackupMonitorEntity() throws Exception {
 224         logger.info("testBackupMonitorEntity: Entering");
 225
 226         dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 227         DbAudit dbAudit = new DbAudit(dbDAO);
 228
 229         BackUpMonitorEntity entry1 = new BackUpMonitorEntity();
 230         BackUpMonitorEntity entry2 = new BackUpMonitorEntity();
 231
 232         // Two entries with the same field values
 233
 234
 235         entry1.setFlag("flag1");
 236         entry1.setResourceNodeName("node1");
 237         entry1.setResourceName("resourceName");
 238         entry1.setTimeStamp(new Date());
 239
 240         // Clone the first entry
 241         entry2 = SerializationUtils.clone(entry1);
 242
 243         HashMap<Object, Object> myEntries = new HashMap<>();
 244         HashMap<Object, Object> theirEntries = new HashMap<>();
 245
 246         myEntries.put("pdp1", entry1);
 247         theirEntries.put("pdp1", entry2);
 248
 249         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 250
 251
 252         // Assert that there are no mismatches returned
 253
 254         assertTrue(result.isEmpty());
 255
 256
 257          /* ************************************
 258          * Now test with a mis-matched entry
 259          * ************************************/
 260
 261
 262
 263         // Change a field on entry2
 264
 265         entry2.setFlag("flag2");
 266
 267         myEntries = new HashMap<>();
 268         theirEntries = new HashMap<>();
 269
 270         myEntries.put("pdp1", entry1);
 271         theirEntries.put("pdp1", entry2);
 272
 273         result = dbAudit.compareEntries(myEntries, theirEntries);
 274
 275
 276         //Assert that there was one mismatch
 277
 278         assertEquals(1, result.size());
 279         logger.info("testBackupMonitorEntity: Exit");
 280     }
 281
 282     void testStateManagementEntity() throws Exception {
 283         logger.info("testStateManagementEntity: Entering");
 284
 285         dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 286         DbAudit dbAudit = new DbAudit(dbDAO);
 287
 288         StateManagementEntity entry1 = new StateManagementEntity();
 289         StateManagementEntity entry2 = new StateManagementEntity();
 290
 291         // Two entries with the same field values
 292
 293         entry1.setAdminState("locked");
 294         entry1.setAvailStatus("null");
 295         entry1.setModifiedDate(new Date());
 296         entry1.setOpState("enabled");
 297         entry1.setResourceName("myResource");
 298         entry1.setStandbyStatus("coldstandby");
 299
 300         // Clone the first entry
 301         entry2 = SerializationUtils.clone(entry1);
 302
 303         HashMap<Object, Object> myEntries = new HashMap<>();
 304         HashMap<Object, Object> theirEntries = new HashMap<>();
 305
 306         myEntries.put("pdp1", entry1);
 307         theirEntries.put("pdp1", entry2);
 308
 309         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 310
 311
 312         // Assert that there are no mismatches returned
 313
 314         assertTrue(result.isEmpty());
 315
 316
 317          /* ************************************
 318          * Now test with a mis-matched entry
 319          * ************************************/
 320
 321
 322
 323         // Change a field on entry2
 324
 325         entry2.setAdminState("unlocked");
 326
 327         myEntries = new HashMap<>();
 328         theirEntries = new HashMap<>();
 329
 330         myEntries.put("pdp1", entry1);
 331         theirEntries.put("pdp1", entry2);
 332
 333         result = dbAudit.compareEntries(myEntries, theirEntries);
 334
 335
 336         //Assert that there was one mismatch
 337
 338         assertEquals(1, result.size());
 339         logger.info("testStateManagementEntity: Exit");
 340     }
 341
 342     void testForwardProgressEntity() throws Exception {
 343         logger.info("testForwardProgressEntity: Entering");
 344
 345         dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 346         DbAudit dbAudit = new DbAudit(dbDAO);
 347
 348         ForwardProgressEntity entry1 = new ForwardProgressEntity();
 349         ForwardProgressEntity entry2 = new ForwardProgressEntity();
 350
 351         // Two entries with the same field values
 352
 353         entry1.setFpcCount(123L);
 354         entry1.setLastUpdated(new Date());
 355         entry1.setResourceName("myResource");
 356
 357         // Clone the first entry
 358         entry2 = SerializationUtils.clone(entry1);
 359
 360         HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 361         HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 362
 363         myEntries.put("pdp1", entry1);
 364         theirEntries.put("pdp1", entry2);
 365
 366         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 367
 368
 369         // Assert that there are no mismatches returned
 370
 371         assertTrue(result.isEmpty());
 372
 373
 374          /* ************************************
 375          * Now test with a mis-matched entry
 376          * ************************************/
 377
 378         // Change a field on entry2
 379
 380         entry2.setFpcCount(321L);
 381
 382         myEntries = new HashMap<>();
 383         theirEntries = new HashMap<>();
 384
 385         myEntries.put("pdp1", entry1);
 386         theirEntries.put("pdp1", entry2);
 387
 388         result = dbAudit.compareEntries(myEntries, theirEntries);
 389
 390
 391         //Assert that there was one mismatch
 392
 393         assertEquals(1, result.size());
 394         logger.info("testForwardProgressEntity: Exit");
 395     }
 396
 397     void testResourceRegistrationEntity() throws Exception {
 398         logger.info("testResourceRegistrationEntity: Entering");
 399
 400         dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 401         DbAudit dbAudit = new DbAudit(dbDAO);
 402
 403         ResourceRegistrationEntity entry1 = new ResourceRegistrationEntity();
 404         ResourceRegistrationEntity entry2 = new ResourceRegistrationEntity();
 405
 406         // Two entries with the same field values
 407
 408         entry1.setNodeType("pap");
 409         entry1.setLastUpdated(new Date());
 410         entry1.setResourceName("myResource");
 411         entry1.setResourceUrl("http://nowhere.com");
 412         entry1.setSite("site_1");
 413
 414         // Clone the first entry
 415         entry2 = SerializationUtils.clone(entry1);
 416
 417         HashMap<Object, Object> myEntries = new HashMap<>();
 418         HashMap<Object, Object> theirEntries = new HashMap<>();
 419
 420         myEntries.put("pdp1", entry1);
 421         theirEntries.put("pdp1", entry2);
 422
 423         Set<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 424
 425
 426         // Assert that there are no mismatches returned
 427
 428         assertTrue(result.isEmpty());
 429
 430
 431          /* ************************************
 432          * Now test with a mis-matched entry
 433          * ************************************/
 434
 435         // Change a field on entry2
 436
 437         entry2.setSite("site_1a");
 438
 439         myEntries = new HashMap<>();
 440         theirEntries = new HashMap<>();
 441
 442         myEntries.put("pdp1", entry1);
 443         theirEntries.put("pdp1", entry2);
 444
 445         result = dbAudit.compareEntries(myEntries, theirEntries);
 446
 447
 448         //Assert that there was one mismatch
 449
 450         assertEquals(1, result.size());
 451         logger.info("testResourceRegistrationEntity: Exit");
 452     }
 453 }