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 }