ECOMP-PAP-REST/src/test/java/org/openecomp/policy/pap/ia/DbAuditCompareEntriesTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP-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.openecomp.policy.pap.ia;
  22
  23 import static org.junit.Assert.*;
  24
  25 import java.util.Date;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.Properties;
  29
  30 import javax.persistence.EntityManager;
  31 import javax.persistence.EntityManagerFactory;
  32 import javax.persistence.EntityTransaction;
  33 import javax.persistence.Persistence;
  34
  35 import org.apache.commons.logging.Log;
  36 import org.apache.commons.logging.LogFactory;
  37 import org.junit.After;
  38 import org.junit.Before;
  39 import org.junit.Ignore;
  40 import org.junit.Test;
  41 import org.openecomp.policy.jpa.BackUpMonitorEntity;
  42 import org.openecomp.policy.rest.jpa.ActionBodyEntity;
  43 import org.openecomp.policy.rest.jpa.ActionList;
  44 import org.openecomp.policy.rest.jpa.ActionPolicyDict;
  45 import org.openecomp.policy.rest.jpa.AddressGroup;
  46 import org.openecomp.policy.rest.jpa.Attribute;
  47 import org.openecomp.policy.rest.jpa.AttributeAssignment;
  48 import org.openecomp.policy.rest.jpa.BRMSParamTemplate;
  49 import org.openecomp.policy.rest.jpa.Category;
  50 import org.openecomp.policy.rest.jpa.ClosedLoopD2Services;
  51 import org.openecomp.policy.rest.jpa.ClosedLoopSite;
  52 import org.openecomp.policy.rest.jpa.ConfigurationDataEntity;
  53 import org.openecomp.policy.rest.jpa.ConstraintType;
  54 import org.openecomp.policy.rest.jpa.ConstraintValue;
  55 import org.openecomp.policy.rest.jpa.DCAEUsers;
  56 import org.openecomp.policy.rest.jpa.DCAEuuid;
  57 import org.openecomp.policy.rest.jpa.DatabaseLockEntity;
  58 import org.openecomp.policy.rest.jpa.Datatype;
  59 import org.openecomp.policy.rest.jpa.DecisionSettings;
  60 import org.openecomp.policy.rest.jpa.DescriptiveScope;
  61 import org.openecomp.policy.rest.jpa.EcompName;
  62 import org.openecomp.policy.rest.jpa.EnforcingType;
  63 import org.openecomp.policy.rest.jpa.FunctionArgument;
  64 import org.openecomp.policy.rest.jpa.FunctionDefinition;
  65 import org.openecomp.policy.rest.jpa.GlobalRoleSettings;
  66 import org.openecomp.policy.rest.jpa.GroupEntity;
  67 import org.openecomp.policy.rest.jpa.GroupPolicyScopeList;
  68 import org.openecomp.policy.rest.jpa.GroupServiceList;
  69 import org.openecomp.policy.rest.jpa.MicroServiceConfigName;
  70 import org.openecomp.policy.rest.jpa.MicroServiceLocation;
  71 import org.openecomp.policy.rest.jpa.MicroServiceModels;
  72 import org.openecomp.policy.rest.jpa.Obadvice;
  73 import org.openecomp.policy.rest.jpa.ObadviceExpression;
  74 import org.openecomp.policy.rest.jpa.PEPOptions;
  75 import org.openecomp.policy.rest.jpa.PIPConfigParam;
  76 import org.openecomp.policy.rest.jpa.PIPConfiguration;
  77 import org.openecomp.policy.rest.jpa.PIPResolver;
  78 import org.openecomp.policy.rest.jpa.PIPResolverParam;
  79 import org.openecomp.policy.rest.jpa.PIPType;
  80 import org.openecomp.policy.rest.jpa.PREFIXLIST;
  81 import org.openecomp.policy.rest.jpa.PdpEntity;
  82 import org.openecomp.policy.rest.jpa.PolicyAlgorithms;
  83 import org.openecomp.policy.rest.jpa.PolicyDBDaoEntity;
  84 import org.openecomp.policy.rest.jpa.PolicyEntity;
  85 import org.openecomp.policy.rest.jpa.PolicyManagement;
  86 import org.openecomp.policy.rest.jpa.PolicyRoles;
  87 import org.openecomp.policy.rest.jpa.PolicyScopeClosedLoop;
  88 import org.openecomp.policy.rest.jpa.PolicyScopeResource;
  89 import org.openecomp.policy.rest.jpa.PolicyScopeService;
  90 import org.openecomp.policy.rest.jpa.PolicyScopeType;
  91 import org.openecomp.policy.rest.jpa.PolicyScore;
  92 import org.openecomp.policy.rest.jpa.PolicyVersion;
  93 import org.openecomp.policy.rest.jpa.PortList;
  94 import org.openecomp.policy.rest.jpa.ProtocolList;
  95 import org.openecomp.policy.rest.jpa.RemoteCatalogValues;
  96 import org.openecomp.policy.rest.jpa.RuleAlgorithms;
  97 import org.openecomp.policy.rest.jpa.SecurityZone;
  98 import org.openecomp.policy.rest.jpa.ServiceList;
  99 import org.openecomp.policy.rest.jpa.SystemLogDB;
 100 import org.openecomp.policy.rest.jpa.TermList;
 101 import org.openecomp.policy.rest.jpa.UserInfo;
 102 import org.openecomp.policy.rest.jpa.VMType;
 103 import org.openecomp.policy.rest.jpa.VNFType;
 104 import org.openecomp.policy.rest.jpa.VSCLAction;
 105 import org.openecomp.policy.rest.jpa.VarbindDictionary;
 106 import org.openecomp.policy.rest.jpa.Zone;
 107
 108 import org.openecomp.policy.common.ia.DbAudit;
 109 import org.openecomp.policy.common.ia.DbDAO;
 110 import org.openecomp.policy.common.ia.IntegrityAuditProperties;
 111 import org.openecomp.policy.common.ia.jpa.IntegrityAuditEntity;
 112 import org.openecomp.policy.common.im.jpa.ForwardProgressEntity;
 113 import org.openecomp.policy.common.im.jpa.ResourceRegistrationEntity;
 114 import org.openecomp.policy.common.im.jpa.StateManagementEntity;
 115
 116 import org.apache.commons.lang3.SerializationUtils;
 117
 118 @Ignore
 119 public class DbAuditCompareEntriesTest {
 120
 121         private static Log logger = LogFactory.getLog(DbAuditCompareEntriesTest.class);
 122         private DbDAO dbDAO;
 123         private String persistenceUnit;
 124         private Properties properties;
 125         private String resourceName;
 126         private String dbDriver;
 127         private String dbUrl;
 128         private String dbUser;
 129         private String dbPwd;
 130         private String siteName;
 131         private String nodeType;
 132
 133         @Before
 134         public void setUp() throws Exception {
 135                 logger.info("setUp: Entering");
 136
 137                 properties = new Properties();
 138                 properties.put(IntegrityAuditProperties.DB_DRIVER, IntegrityAuditProperties.DEFAULT_DB_DRIVER);
 139                 properties.put(IntegrityAuditProperties.DB_URL, "jdbc:h2:file:./sql/xacmlTest");
 140                 properties.put(IntegrityAuditProperties.DB_USER, IntegrityAuditProperties.DEFAULT_DB_USER);
 141                 properties.put(IntegrityAuditProperties.DB_PWD, IntegrityAuditProperties.DEFAULT_DB_PWD);
 142                 properties.put(IntegrityAuditProperties.SITE_NAME, "SiteA");
 143                 properties.put(IntegrityAuditProperties.NODE_TYPE, "pap");
 144
 145                 dbDriver = IntegrityAuditProperties.DEFAULT_DB_DRIVER;
 146                 dbUrl = "jdbc:h2:file:./sql/xacmlTest";
 147                 dbUser = IntegrityAuditProperties.DEFAULT_DB_USER;
 148                 dbPwd = IntegrityAuditProperties.DEFAULT_DB_PWD;
 149                 siteName = "SiteA";
 150                 nodeType = "pap";
 151                 persistenceUnit = "testPapPU";
 152                 resourceName = "siteA.pap1";
 153
 154                 //Clean the iaTest DB table for IntegrityAuditEntity entries
 155                 cleanDb(persistenceUnit, properties);
 156
 157                 logger.info("setUp: Exiting");
 158         }
 159
 160         @After
 161         public void tearDown() throws Exception {
 162                 logger.info("tearDown: Entering");
 163                 //nothing to do
 164                 logger.info("tearDown: Exiting");
 165         }
 166
 167         public void cleanDb(String persistenceUnit, Properties properties){
 168                 logger.debug("cleanDb: enter");
 169
 170                 EntityManagerFactory emf = Persistence.createEntityManagerFactory(persistenceUnit, properties);
 171
 172                 EntityManager em = emf.createEntityManager();
 173                 // Start a transaction
 174                 EntityTransaction et = em.getTransaction();
 175
 176                 et.begin();
 177
 178                 // Clean up the DB
 179                 em.createQuery("Delete from IntegrityAuditEntity").executeUpdate();
 180
 181                 // commit transaction
 182                 et.commit();
 183                 em.close();
 184                 logger.debug("cleanDb: exit");
 185         }
 186
 187
 188         /*
 189          * Tests that a comparison between hashsets is successful if
 190          * the entries match
 191          */
 192         //@Ignore
 193         @Test
 194         public void runAllTests() throws Exception {
 195                 logger.info("runAllTests: Entering");
 196
 197
 198                 testIntegrityAuditEntity();
 199                 testBackupMonitorEntity();
 200                 testStateManagementEntity();
 201                 testForwardProgressEntity();
 202                 testResourceRegistrationEntity();
 203
 204                 //clean up the IntegrityAuditEntity table
 205                 cleanDb(persistenceUnit, properties);
 206
 207                 logger.info("runAllTests: Exit");
 208         }
 209
 210
 211         public void testIntegrityAuditEntity() throws Exception {
 212                 logger.info("testIntegrityAuditEntity: Entering");
 213
 214                 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 215                 DbAudit dbAudit = new DbAudit(dbDAO);
 216
 217                 String className = null;
 218                 //There is only one entry IntegrityAuditEntity, but we will check anyway
 219                 HashSet<String> classNameSet = dbDAO.getPersistenceClassNames();
 220                 for(String c : classNameSet){
 221                         if (c.equals("org.openecomp.policy.common.ia.IntegrityAuditEntity")){
 222                                 className = c;
 223                         }
 224                 }
 225                 String resourceName1 = resourceName;
 226                 String resourceName2 = resourceName;
 227
 228                 IntegrityAuditEntity entry1 = new IntegrityAuditEntity();
 229                 IntegrityAuditEntity entry2 = new IntegrityAuditEntity();
 230                 Date date = new Date();
 231
 232                 /*
 233                  * Two entries with the same field values
 234                  */
 235                 entry1.setDesignated(false);
 236                 entry1.setJdbcDriver(dbDriver);
 237                 entry1.setJdbcPassword(dbPwd);
 238                 entry1.setJdbcUrl(dbUrl);
 239                 entry1.setJdbcUser(dbUser);
 240                 entry1.setLastUpdated(date);
 241                 entry1.setNodeType(nodeType);
 242                 entry1.setPersistenceUnit(persistenceUnit);
 243                 entry1.setResourceName(resourceName1);
 244                 entry1.setSite(siteName);
 245
 246                 entry2 = SerializationUtils.clone(entry1);
 247
 248                 dbAudit.writeAuditDebugLog(className, resourceName1, resourceName2, entry1, entry2);
 249
 250                 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 251                 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 252
 253                 myEntries.put("pdp1", entry1);
 254                 theirEntries.put("pdp1", entry2);
 255
 256                 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 257
 258                 /*
 259                  * Assert that there are no mismatches returned
 260                  */
 261                 assertTrue(result.isEmpty());
 262
 263                 /*
 264                  * ************************************
 265                  * Now test with a mis-matched entry
 266                  * ************************************
 267                  */
 268
 269                 /*
 270                  * Change the entry2 to different designated value
 271                  */
 272                 entry2.setDesignated(true);
 273
 274                 myEntries = new HashMap<Object, Object>();
 275                 theirEntries = new HashMap<Object, Object>();
 276
 277                 myEntries.put("pdp1", entry1);
 278                 theirEntries.put("pdp1", entry2);
 279
 280                 result = dbAudit.compareEntries(myEntries, theirEntries);
 281
 282                 /*
 283                  * Assert that there was one mismatch
 284                  */
 285                 assertEquals(1, result.size());
 286                 logger.info("testIntegrityAuditEntity: Exit");
 287         }
 288
 289         void testBackupMonitorEntity() throws Exception {
 290                 logger.info("testBackupMonitorEntity: Entering");
 291
 292                 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 293                 DbAudit dbAudit = new DbAudit(dbDAO);
 294
 295                 BackUpMonitorEntity entry1 = new BackUpMonitorEntity();
 296                 BackUpMonitorEntity entry2 = new BackUpMonitorEntity();
 297
 298                 // Two entries with the same field values
 299
 300
 301                 entry1.setFlag("flag1");
 302                 entry1.setResoruceNodeName("node1");
 303                 entry1.setResourceName("resourceName");
 304                 entry1.setTimeStamp(new Date());
 305
 306                 // Clone the first entry
 307                 entry2 = SerializationUtils.clone(entry1);
 308
 309                 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 310                 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 311
 312                 myEntries.put("pdp1", entry1);
 313                 theirEntries.put("pdp1", entry2);
 314
 315                 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 316
 317
 318                 // Assert that there are no mismatches returned
 319
 320                 assertTrue(result.isEmpty());
 321
 322
 323                  /* ************************************
 324                  * Now test with a mis-matched entry
 325                  * ************************************/
 326
 327
 328
 329                 // Change a field on entry2
 330
 331                 entry2.setFlag("flag2");
 332
 333                 myEntries = new HashMap<Object, Object>();
 334                 theirEntries = new HashMap<Object, Object>();
 335
 336                 myEntries.put("pdp1", entry1);
 337                 theirEntries.put("pdp1", entry2);
 338
 339                 result = dbAudit.compareEntries(myEntries, theirEntries);
 340
 341
 342                 //Assert that there was one mismatch
 343
 344                 assertEquals(1, result.size());
 345                 logger.info("testBackupMonitorEntity: Exit");
 346         }
 347
 348         void testStateManagementEntity() throws Exception {
 349                 logger.info("testStateManagementEntity: Entering");
 350
 351                 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 352                 DbAudit dbAudit = new DbAudit(dbDAO);
 353
 354                 StateManagementEntity entry1 = new StateManagementEntity();
 355                 StateManagementEntity entry2 = new StateManagementEntity();
 356
 357                 // Two entries with the same field values
 358
 359                 entry1.setAdminState("locked");
 360                 entry1.setAvailStatus("null");
 361                 entry1.setModifiedDate(new Date());
 362                 entry1.setOpState("enabled");
 363                 entry1.setResourceName("myResource");
 364                 entry1.setStandbyStatus("coldstandby");
 365
 366                 // Clone the first entry
 367                 entry2 = SerializationUtils.clone(entry1);
 368
 369                 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 370                 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 371
 372                 myEntries.put("pdp1", entry1);
 373                 theirEntries.put("pdp1", entry2);
 374
 375                 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 376
 377
 378                 // Assert that there are no mismatches returned
 379
 380                 assertTrue(result.isEmpty());
 381
 382
 383                  /* ************************************
 384                  * Now test with a mis-matched entry
 385                  * ************************************/
 386
 387
 388
 389                 // Change a field on entry2
 390
 391                 entry2.setAdminState("unlocked");
 392
 393                 myEntries = new HashMap<Object, Object>();
 394                 theirEntries = new HashMap<Object, Object>();
 395
 396                 myEntries.put("pdp1", entry1);
 397                 theirEntries.put("pdp1", entry2);
 398
 399                 result = dbAudit.compareEntries(myEntries, theirEntries);
 400
 401
 402                 //Assert that there was one mismatch
 403
 404                 assertEquals(1, result.size());
 405                 logger.info("testStateManagementEntity: Exit");
 406         }
 407
 408         void testForwardProgressEntity() throws Exception {
 409                 logger.info("testForwardProgressEntity: Entering");
 410
 411                 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 412                 DbAudit dbAudit = new DbAudit(dbDAO);
 413
 414                 ForwardProgressEntity entry1 = new ForwardProgressEntity();
 415                 ForwardProgressEntity entry2 = new ForwardProgressEntity();
 416
 417                 // Two entries with the same field values
 418
 419                 entry1.setFpcCount(123L);
 420                 entry1.setLastUpdated(new Date());
 421                 entry1.setResourceName("myResource");
 422
 423                 // Clone the first entry
 424                 entry2 = SerializationUtils.clone(entry1);
 425
 426                 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 427                 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 428
 429                 myEntries.put("pdp1", entry1);
 430                 theirEntries.put("pdp1", entry2);
 431
 432                 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 433
 434
 435                 // Assert that there are no mismatches returned
 436
 437                 assertTrue(result.isEmpty());
 438
 439
 440                  /* ************************************
 441                  * Now test with a mis-matched entry
 442                  * ************************************/
 443
 444                 // Change a field on entry2
 445
 446                 entry2.setFpcCount(321L);
 447
 448                 myEntries = new HashMap<Object, Object>();
 449                 theirEntries = new HashMap<Object, Object>();
 450
 451                 myEntries.put("pdp1", entry1);
 452                 theirEntries.put("pdp1", entry2);
 453
 454                 result = dbAudit.compareEntries(myEntries, theirEntries);
 455
 456
 457                 //Assert that there was one mismatch
 458
 459                 assertEquals(1, result.size());
 460                 logger.info("testForwardProgressEntity: Exit");
 461         }
 462
 463         void testResourceRegistrationEntity() throws Exception {
 464                 logger.info("testResourceRegistrationEntity: Entering");
 465
 466                 dbDAO = new DbDAO(resourceName, persistenceUnit, properties);
 467                 DbAudit dbAudit = new DbAudit(dbDAO);
 468
 469                 ResourceRegistrationEntity entry1 = new ResourceRegistrationEntity();
 470                 ResourceRegistrationEntity entry2 = new ResourceRegistrationEntity();
 471
 472                 // Two entries with the same field values
 473
 474                 entry1.setNodeType("pap");
 475                 entry1.setLastUpdated(new Date());
 476                 entry1.setResourceName("myResource");
 477                 entry1.setResourceUrl("http://nowhere.com");
 478                 entry1.setSite("site_1");
 479
 480                 // Clone the first entry
 481                 entry2 = SerializationUtils.clone(entry1);
 482
 483                 HashMap<Object, Object> myEntries = new HashMap<Object, Object>();
 484                 HashMap<Object, Object> theirEntries = new HashMap<Object, Object>();
 485
 486                 myEntries.put("pdp1", entry1);
 487                 theirEntries.put("pdp1", entry2);
 488
 489                 HashSet<Object> result = dbAudit.compareEntries(myEntries, theirEntries);
 490
 491
 492                 // Assert that there are no mismatches returned
 493
 494                 assertTrue(result.isEmpty());
 495
 496
 497                  /* ************************************
 498                  * Now test with a mis-matched entry
 499                  * ************************************/
 500
 501                 // Change a field on entry2
 502
 503                 entry2.setSite("site_1a");
 504
 505                 myEntries = new HashMap<Object, Object>();
 506                 theirEntries = new HashMap<Object, Object>();
 507
 508                 myEntries.put("pdp1", entry1);
 509                 theirEntries.put("pdp1", entry2);
 510
 511                 result = dbAudit.compareEntries(myEntries, theirEntries);
 512
 513
 514                 //Assert that there was one mismatch
 515
 516                 assertEquals(1, result.size());
 517                 logger.info("testResourceRegistrationEntity: Exit");
 518         }
 519 }