integration-tests/src/test/java/org/onap/sdc/backend/ci/tests/utils/validation/AuditValidationUtils.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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.sdc.backend.ci.tests.utils.validation;
  22
  23 import com.datastax.driver.core.ColumnDefinitions;
  24 import com.datastax.driver.core.Row;
  25 import java.io.FileNotFoundException;
  26 import java.io.IOException;
  27 import java.util.*;
  28 import org.apache.logging.log4j.Logger;
  29 import org.apache.logging.log4j.LogManager;
  30 import org.codehaus.jettison.json.JSONArray;
  31 import org.codehaus.jettison.json.JSONException;
  32 import org.codehaus.jettison.json.JSONObject;
  33 import org.javatuples.Pair;
  34 import org.onap.sdc.backend.ci.tests.datatypes.enums.AuditEnum;
  35 import org.onap.sdc.backend.ci.tests.datatypes.enums.AuditJsonKeysEnum;
  36 import org.onap.sdc.backend.ci.tests.datatypes.enums.ComponentType;
  37 import org.onap.sdc.backend.ci.tests.datatypes.enums.ErrorInfo;
  38 import org.onap.sdc.backend.ci.tests.datatypes.expected.*;
  39 import org.onap.sdc.backend.ci.tests.datatypes.http.HttpRequest;
  40 import org.onap.sdc.backend.ci.tests.datatypes.http.RestResponse;
  41 import org.onap.sdc.backend.ci.tests.utils.cassandra.CassandraUtils;
  42 import org.openecomp.sdc.be.dao.api.ActionStatus;
  43 import org.openecomp.sdc.be.datatypes.elements.ConsumerDataDefinition;
  44 import org.openecomp.sdc.be.model.ArtifactDefinition;
  45 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  46 import org.openecomp.sdc.be.model.User;
  47 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  48 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  49 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  50 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  51 import org.onap.sdc.backend.ci.tests.api.Urls;
  52 import org.onap.sdc.backend.ci.tests.config.Config;
  53 import org.onap.sdc.backend.ci.tests.datatypes.ServiceReqDetails;
  54 import org.onap.sdc.backend.ci.tests.utils.Utils;
  55 import org.onap.sdc.backend.ci.tests.utils.rest.BaseRestUtils;
  56 import org.onap.sdc.backend.ci.tests.utils.rest.CategoryRestUtils.CategoryAuditJsonKeysEnum;
  57 import org.onap.sdc.backend.ci.tests.utils.rest.ConsumerRestUtils.EcompConsumerAuditJsonKeysEnum;
  58 import org.onap.sdc.backend.ci.tests.utils.rest.ResponseParser;
  59 import org.openecomp.sdc.common.api.Constants;
  60 import org.openecomp.sdc.common.datastructure.AuditingFieldsKey;
  61
  62 import static org.testng.AssertJUnit.assertEquals;
  63 import static org.testng.AssertJUnit.assertTrue;
  64
  65 public class AuditValidationUtils {
  66         protected static Logger logger = LogManager.getLogger(AuditValidationUtils.class);
  67         private static final String auditKeySpaceName = "sdcaudit";
  68
  69         public AuditValidationUtils() {
  70                 super();
  71                 logger = LogManager.getLogger(AuditValidationUtils.class);
  72
  73         }
  74
  75         public static String buildAuditDescription(ErrorInfo errorInfo, List<String> errorVariablesList) {
  76                 String auditDesc;
  77                 if(errorInfo.getMessageId() != null){
  78                         auditDesc = errorInfo.getMessageId() + ": " + errorInfo.getMessage();
  79                         }else{
  80                                 auditDesc = errorInfo.getMessage();
  81                         }
  82
  83 //              if(! variables.isEmpty() && variables.get(0) != null && ! variables.get(0).isEmpty()){
  84 //                      for (int i = 0; i < variables.size(); i++) {
  85 //                              if (auditDesc.contains("%" + (i + 1))) {
  86 //                                      auditDesc = auditDesc.replace("%" + (i + 1), variables.get(i));
  87 //                              }
  88 //                      }
  89 //              }
  90                 if(errorVariablesList != null && ! errorVariablesList.isEmpty() && errorVariablesList.get(0) != null){
  91                         for (int i = 0; i < errorVariablesList.size(); i++) {
  92                                 if (auditDesc.contains("%" + (i + 1))) {
  93                                         auditDesc = auditDesc.replace("%" + (i + 1), errorVariablesList.get(i));
  94                                 }
  95                         }
  96                 }
  97                 return auditDesc;
  98         }
  99
 100         public static String getModifierString(String userName, String uid) {
 101
 102                 if (userName.isEmpty() && uid.isEmpty())
 103                         return "(UNKNOWN)";
 104
 105                 StringBuilder sb = new StringBuilder();
 106                 sb.append(userName).append("(").append(uid).append(")");
 107                 return sb.toString();
 108
 109         }
 110
 111         public static void validateAuditDownloadExternalAPI(ExpectedResourceAuditJavaObject resourceAuditJavaObject,
 112                                                         String action, String body, boolean checkAllFields) throws Exception {
 113                 Map<String, Object> actualAuditRecords = parseAuditResourceByAction(action, null);
 114
 115                 validateField(actualAuditRecords, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 116                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 117                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 118                 validateField(actualAuditRecords, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 119                 validateField(actualAuditRecords, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 120
 121         }
 122
 123         public static void validateAudit(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action, String body, boolean checkAllFields) throws Exception {
 124                 Map<String, Object> actualAuditRecords = parseAuditResourceByAction(action, null);
 125
 126                 if ((resourceAuditJavaObject.getModifierName() != null) && (resourceAuditJavaObject.getModifierUid() != null)) {
 127                         resourceAuditJavaObject.setModifierUid(getModifierString(resourceAuditJavaObject.getModifierName(),
 128                                         resourceAuditJavaObject.getModifierUid()));
 129                 }
 130
 131                 validateField(actualAuditRecords, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 132                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 133                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 134                 validateField(actualAuditRecords, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevVersion());
 135                 validateField(actualAuditRecords, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 136
 137                 validateField(actualAuditRecords, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 138                 validateField(actualAuditRecords, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevState());
 139                 validateField(actualAuditRecords, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 140                 validateField(actualAuditRecords, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 141                 validateField(actualAuditRecords, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 142                 validateField(actualAuditRecords, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
 143                 validateField(actualAuditRecords, AuditJsonKeysEnum.TOSCA_NODE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getToscaNodeType());
 144                 validateField(actualAuditRecords, AuditJsonKeysEnum.CURR_ARTIFACT_UUID.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrArtifactUuid());
 145                 validateField(actualAuditRecords, AuditJsonKeysEnum.PREV_ARTIFACT_UUID.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevArtifactUuid());
 146
 147                 validateAtifactDataField(actualAuditRecords, AuditJsonKeysEnum.ARTIFACT_DATA.getAuditJsonKeyName(), resourceAuditJavaObject.getArtifactData(), checkAllFields);
 148         }
 149
 150         public static void validateExternalAudit(ExpectedExternalAudit externalAuditObject, String action, Map<AuditingFieldsKey, String> body) throws Exception {
 151
 152                 Map<String, Object> actualAuditRecord = parseAuditResourceByAction(action, body);
 153
 154                 validateField(actualAuditRecord, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 155                 validateField(actualAuditRecord, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), externalAuditObject.getCONSUMER_ID());
 156                 // TODO
 157                 validateField(actualAuditRecord, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), externalAuditObject.getRESOURCE_URL());
 158                 //TODO
 159                 validateField(actualAuditRecord, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), externalAuditObject.getRESOURCE_NAME());
 160                 validateField(actualAuditRecord, AuditJsonKeysEnum.SERVICE_INSTANCE_ID.getAuditJsonKeyName(), externalAuditObject.getSERVICE_INSTANCE_ID());
 161                 //TODO
 162                 validateField(actualAuditRecord, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), externalAuditObject.getRESOURCE_TYPE());
 163                 validateField(actualAuditRecord, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), externalAuditObject.getSTATUS());
 164                 validateField(actualAuditRecord, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), externalAuditObject.getDESC());
 165                 //TODO
 166 //              validateField(actualAuditRecord, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), externalAuditObject.getMODIFIER());
 167                 validateField(actualAuditRecord, AuditJsonKeysEnum.PREV_ARTIFACT_UUID.getAuditJsonKeyName(), externalAuditObject.getPREV_ARTIFACT_UUID());
 168                 validateField(actualAuditRecord, AuditJsonKeysEnum.CURR_ARTIFACT_UUID.getAuditJsonKeyName(), externalAuditObject.getCURR_ARTIFACT_UUID());
 169                 //TODO
 170                 validateField(actualAuditRecord, AuditJsonKeysEnum.ARTIFACT_DATA.getAuditJsonKeyName(), externalAuditObject.getARTIFACT_DATA());
 171
 172         }
 173
 174         public enum ArtifactDataFieldEnum {
 175                 attGroup, artLabel, artType, artName, artTimeout, artPayloadUUID, artVersion, artUUID
 176         }
 177
 178         private static void validateAtifactDataField(Map<String, Object> map, String auditJsonKeyName,
 179                         String expectedArtifactData, boolean checkAllFields) {
 180                 Map<ArtifactDataFieldEnum, String> expectedArtifactDataFileds = new HashMap<ArtifactDataFieldEnum, String>();
 181                 Map<ArtifactDataFieldEnum, String> actualAtifactDataFileds = new HashMap<ArtifactDataFieldEnum, String>();
 182                 if (expectedArtifactData != null) {
 183                         String[] expected = expectedArtifactData.split(",");
 184
 185                         assertTrue("Audit field " + auditJsonKeyName + " not found", map.containsKey(auditJsonKeyName));
 186                         String actualValue = (String) map.get(auditJsonKeyName);
 187                         String[] actual = actualValue.split(",");
 188
 189                         if (expected.length == 1 && actual.length == 1) {
 190                                 assertEquals(expectedArtifactData, actualValue);
 191                                 return;
 192                         }
 193
 194                         assertEquals(ArtifactDataFieldEnum.values().length, expected.length);
 195                         assertEquals(ArtifactDataFieldEnum.values().length, actual.length);
 196
 197                         for (ArtifactDataFieldEnum field : ArtifactDataFieldEnum.values()) {
 198
 199                                 expectedArtifactDataFileds.put(field, expected[field.ordinal()]);
 200                                 actualAtifactDataFileds.put(field, actual[field.ordinal()]);
 201                         }
 202                         for (Map.Entry<ArtifactDataFieldEnum, String> entry : expectedArtifactDataFileds.entrySet()) {
 203                                 ArtifactDataFieldEnum field = entry.getKey();
 204                                 if (checkAllFields || (!field.equals(ArtifactDataFieldEnum.artVersion)
 205                                                 && !field.equals(ArtifactDataFieldEnum.artUUID))) {
 206                                         assertTrue("Audit field ArtifactData dosn't containt " + field,
 207                                                         actualAtifactDataFileds.containsKey(field));
 208                                         assertEquals("Audit field ArtifactData dosn't equal " + field,
 209                                                         expectedArtifactDataFileds.get(field), actualAtifactDataFileds.get(field));
 210                                 }
 211
 212                         }
 213                 }
 214         }
 215
 216         // //Benny
 217         public static void validateEcompConsumerAudit(ExpectedEcomConsumerAudit ecompConsumerAuditJavaObject, String action) throws Exception {
 218
 219                 String fixedAction = BaseRestUtils.encodeUrlForDownload(action);
 220                 Map<String, Object> map2 = parseAuditResourceByAction(fixedAction, null);
 221
 222                 validateField(map2, EcompConsumerAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), ecompConsumerAuditJavaObject.getModifier());
 223                 validateField(map2, EcompConsumerAuditJsonKeysEnum.ECOMP_USER.getAuditJsonKeyName(), ecompConsumerAuditJavaObject.getEcomUser());
 224                 validateField(map2, EcompConsumerAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), ecompConsumerAuditJavaObject.getStatus());
 225                 validateField(map2, EcompConsumerAuditJsonKeysEnum.DESC.getAuditJsonKeyName(), ecompConsumerAuditJavaObject.getDesc());
 226                 validateField(map2, EcompConsumerAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 227         }
 228
 229         public static void ecompConsumerAuditSuccess(String action, ConsumerDataDefinition consumerDataDefinition, User user, int status) throws Exception {
 230                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 231                 expectedEcomConsumerAuditJavaObject.setAction(action);
 232                 expectedEcomConsumerAuditJavaObject.setEcomUser(
 233                                 consumerDataDefinition.getConsumerName() + "," + consumerDataDefinition.getConsumerSalt().toLowerCase()
 234                                                 + "," + consumerDataDefinition.getConsumerPassword().toLowerCase());
 235                 expectedEcomConsumerAuditJavaObject.setStatus(String.valueOf(status));
 236                 expectedEcomConsumerAuditJavaObject.setDesc("OK");
 237                 expectedEcomConsumerAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 238                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject, action);
 239         }
 240
 241         public static void createEcompConsumerAuditFailure(String action, ConsumerDataDefinition consumerDataDefinition,
 242                         User user, ActionStatus errorMessage, Object... variables) throws Exception {
 243                 // validate audit
 244                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 245                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 246                 expectedEcomConsumerAuditJavaObject.setAction(action);
 247                 expectedEcomConsumerAuditJavaObject.setEcomUser(
 248                                 consumerDataDefinition.getConsumerName() + "," + consumerDataDefinition.getConsumerSalt().toLowerCase()
 249                                                 + "," + consumerDataDefinition.getConsumerPassword().toLowerCase());
 250                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 251                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 252                 expectedEcomConsumerAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 253                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject, action);
 254         }
 255
 256         public static void deleteEcompConsumerAuditFailure(String action, ConsumerDataDefinition consumerDataDefinition,
 257                         User user, ActionStatus errorMessage, Object... variables) throws Exception {
 258                 // validate audit
 259                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 260                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 261                 // String auditAction = ADD_ECOMP_USER_CREDENTIALS_AUDIT_ACTION;
 262                 expectedEcomConsumerAuditJavaObject.setAction(action);
 263                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName());
 264                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 265                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 266                 expectedEcomConsumerAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 267                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject, action);
 268         }
 269
 270         ////////////////////// US571255
 271         public static void GetListOfUsersByRolesAuditFailure(String action, String roles, int status, User userModifier,
 272                         ActionStatus errorMessage, Object... variables) throws Exception {
 273                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 274                 ExpectedGetUserListAudit expectedGetListOfUsersAuditJavaObject = new ExpectedGetUserListAudit(); // String
 275                                                                                                                                                                                                                         // auditAction
 276                                                                                                                                                                                                                         // =
 277                                                                                                                                                                                                                         // ADD_ECOMP_USER_CREDENTIALS_AUDIT_ACTION;
 278                 expectedGetListOfUsersAuditJavaObject.setAction(action);
 279                 expectedGetListOfUsersAuditJavaObject.setStatus(String.valueOf(status));
 280                 expectedGetListOfUsersAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 281
 282                 expectedGetListOfUsersAuditJavaObject.setDetails(roles);
 283                 if (errorMessage == ActionStatus.USER_INACTIVE || errorMessage == ActionStatus.MISSING_INFORMATION) {
 284                         expectedGetListOfUsersAuditJavaObject.setModifier("(UNKNOWN)");
 285                 } else {
 286                         expectedGetListOfUsersAuditJavaObject
 287                                         .setModifier(userModifier.getFullName() + "(" + userModifier.getUserId() + ")");
 288                 }
 289                 AuditValidationUtils.validateAuditGetListOfUsersByRoles(expectedGetListOfUsersAuditJavaObject, action);
 290         }
 291
 292         public static void GetListOfUsersByRolesAuditSuccess(String action, String roles, User user, int status)
 293                         throws Exception {
 294                 ExpectedGetUserListAudit expectedGetListOfUsersAuditJavaObject = new ExpectedGetUserListAudit();
 295                 expectedGetListOfUsersAuditJavaObject.setAction(action);
 296                 expectedGetListOfUsersAuditJavaObject.setStatus(String.valueOf(status));
 297                 expectedGetListOfUsersAuditJavaObject.setDesc("OK");
 298                 expectedGetListOfUsersAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 299                 expectedGetListOfUsersAuditJavaObject.setDetails(roles);
 300                 validateAuditGetListOfUsersByRoles(expectedGetListOfUsersAuditJavaObject, action);
 301         }
 302
 303         public static void validateAuditGetListOfUsersByRoles(ExpectedGetUserListAudit GetListOfUsersAuditJavaObject,
 304                         String action) throws Exception {
 305
 306                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 307                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 308                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), GetListOfUsersAuditJavaObject.getStatus());
 309                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), GetListOfUsersAuditJavaObject.getModifier());
 310                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), GetListOfUsersAuditJavaObject.getDesc());
 311                 validateField(map2, AuditJsonKeysEnum.DETAILS.getAuditJsonKeyName(), GetListOfUsersAuditJavaObject.getDetails());
 312         }
 313
 314         public static void validateAuditImport(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action) throws Exception {
 315
 316                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 317
 318                 resourceAuditJavaObject.setModifierUid(getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 319
 320                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 321                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 322                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevVersion());
 323                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 324                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 325                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevState());
 326                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 327                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 328                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 329
 330         }
 331
 332         public static void validateAuditDistribution(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action) throws Exception {
 333
 334                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 335
 336                 resourceAuditJavaObject.setModifierUid(getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 337
 338                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 339                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 340                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 341                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 342                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 343                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 344                 validateField(map2, AuditJsonKeysEnum.DPREV_STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getDprevStatus());
 345                 validateField(map2, AuditJsonKeysEnum.DCURR_STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getDcurrStatus());
 346                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 347                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 348                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
 349                 validateField(map2, AuditJsonKeysEnum.DID.getAuditJsonKeyName(), resourceAuditJavaObject.getDistributionId());
 350
 351         }
 352
 353         // Benny
 354         public static void validateAudit_Distribution(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action) throws Exception {
 355
 356                 List<Map<String, Object>> actionToList = getAuditListByAction(resourceAuditJavaObject.getAction(), 1);
 357                 Map<String, Object> map2 = actionToList.get(0);
 358                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 359                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 360                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 361                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 362                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getMODIFIER());
 363                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 364                 validateField(map2, AuditJsonKeysEnum.DPREV_STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getDprevStatus());
 365                 validateField(map2, AuditJsonKeysEnum.DCURR_STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getDcurrStatus());
 366                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 367                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 368                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
 369
 370         }
 371
 372         public void validateAuditNotification(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action) throws Exception {
 373
 374                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 375
 376                 resourceAuditJavaObject.setModifierUid(getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 377
 378                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 379                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 380                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 381                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 382                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 383                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 384                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 385                 validateField(map2, AuditJsonKeysEnum.DID.getAuditJsonKeyName(), resourceAuditJavaObject.getDistributionId());
 386                 validateField(map2, AuditJsonKeysEnum.TOPIC_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getTopicName());
 387
 388         }
 389
 390         public static void validateAudit(ExpectedDistDownloadAudit expectedDistDownloadAudit, String action) throws Exception {
 391
 392                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 393
 394                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 395                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedDistDownloadAudit.getStatus());
 396                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedDistDownloadAudit.getDesc());
 397                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), expectedDistDownloadAudit.getConsumerId());
 398                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), expectedDistDownloadAudit.getResourceUrl());
 399         }
 400
 401         public static void validateAuditExternalSearchAPI(ExpectedExternalAudit expectedDistDownloadAudit, String action, Map<AuditingFieldsKey, String> body)
 402                         throws Exception {
 403
 404                 Map<String, Object> map2 = parseAuditResourceByAction(action, body);
 405
 406                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 407                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedDistDownloadAudit.getSTATUS());
 408                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedDistDownloadAudit.getDESC());
 409                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), expectedDistDownloadAudit.getCONSUMER_ID());
 410                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), expectedDistDownloadAudit.getRESOURCE_URL());
 411         }
 412
 413         public static void validateAuditExternalCreateResource(ExpectedResourceAuditJavaObject expectedExternalAudit, String action, Map<AuditingFieldsKey, String> body) throws Exception {
 414         Map<String, Object>     map2 = parseAuditResourceByAction(action, body);
 415
 416                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 417                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), expectedExternalAudit.getResourceName());
 418                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), expectedExternalAudit.getResourceType());
 419                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), expectedExternalAudit.getCONSUMER_ID());
 420                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), expectedExternalAudit.getRESOURCE_URL());
 421                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedExternalAudit.getMODIFIER());
 422
 423                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getPrevVersion());
 424                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getCurrVersion());
 425                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), expectedExternalAudit.getPrevState());
 426                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), expectedExternalAudit.getCurrState());
 427
 428                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedExternalAudit.getStatus());
 429                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedExternalAudit.getDesc());
 430         }
 431
 432         public static void validateAuditExternalChangeAssetLifeCycle(ExpectedResourceAuditJavaObject expectedExternalAudit, String action, Map<AuditingFieldsKey, String> body) throws Exception {
 433                 Map<String, Object> map2 = parseAuditResourceByAction(action, body);
 434
 435                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 436                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedExternalAudit.getDesc());
 437                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedExternalAudit.getStatus());
 438
 439                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), expectedExternalAudit.getResourceType());
 440                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), expectedExternalAudit.getResourceName());
 441                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), expectedExternalAudit.getCONSUMER_ID());
 442                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), expectedExternalAudit.getRESOURCE_URL());
 443                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedExternalAudit.getMODIFIER());
 444
 445                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getPrevVersion());
 446                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getCurrVersion());
 447                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), expectedExternalAudit.getPrevState());
 448                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), expectedExternalAudit.getCurrState());
 449
 450         }
 451
 452         public void validateAuditDeploy(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action)
 453                         throws Exception {
 454
 455                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 456
 457                 resourceAuditJavaObject.setModifierUid(getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 458
 459                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 460                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 461                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 462                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 463                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 464                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 465                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 466                 validateField(map2, AuditJsonKeysEnum.DID.getAuditJsonKeyName(), resourceAuditJavaObject.getDistributionId());
 467
 468         }
 469
 470         public static void validateAuditProduct(ExpectedProductAudit productExpectedAudit, String action,
 471                         AuditJsonKeysEnum... additionalFields) throws Exception {
 472
 473                 Map<String, Object> map2 = parseAuditResourceByAction(action, null);
 474
 475                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 476                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), productExpectedAudit.getRESOURCE_NAME());
 477                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), productExpectedAudit.getRESOURCE_TYPE());
 478                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), productExpectedAudit.getPREV_VERSION());
 479                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), productExpectedAudit.getCURR_VERSION());
 480                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), productExpectedAudit.getPREV_STATE());
 481                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), productExpectedAudit.getCURR_STATE());
 482                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), productExpectedAudit.getMODIFIER());
 483                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), productExpectedAudit.getSTATUS());
 484                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), productExpectedAudit.getDESC());
 485                 validateField(map2, AuditJsonKeysEnum.SERVICE_INSTANCE_ID.getAuditJsonKeyName(), productExpectedAudit.getSERVICE_INSTANCE_ID());
 486                 if (additionalFields != null) {
 487                         List<AuditJsonKeysEnum> fieldsList = Arrays.asList(additionalFields);
 488                         if (fieldsList.contains(AuditJsonKeysEnum.COMMENT)) {
 489                                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), productExpectedAudit.getCOMMENT());
 490                         }
 491                 }
 492         }
 493
 494         private static List<Map<String, Object>> getAuditListByAction(String action, int expectedNumOfAudit)
 495                         throws Exception {
 496                 List<Map<String, Object>> actionToList = parseAuditResourceByActionToList(action, null);
 497                 assertEquals("recieved different audits number than expected", expectedNumOfAudit, actionToList.size());
 498                 return actionToList;
 499         }
 500
 501         public static void validateAuthenticationAudit(ExpectedAuthenticationAudit expectedAudit) throws Exception {
 502                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedAudit.getAction(), 1);
 503                 assertEquals("expected number of ES action is 1", 1, actionToList.size());
 504
 505                 Map<String, Object> map = actionToList.get(0);
 506                 validateField(map, AuditEnum.ACTION.getValue(), expectedAudit.getAction());
 507                 validateField(map, AuditEnum.URL.getValue(), expectedAudit.getUrl());
 508                 validateField(map, AuditEnum.USER.getValue(), expectedAudit.getUser());
 509                 validateField(map, AuditEnum.AUTH_STATUS.getValue(), expectedAudit.getAuthStatus());
 510                 validateField(map, AuditEnum.REALM.getValue(), expectedAudit.getRealm());
 511
 512         }
 513
 514         private static void validateField(Map<String, Object> actualAuditRecord, String jsonField, Object expectedValue) {
 515                 if (expectedValue == null) {
 516                         // || changed to &&
 517                         if (actualAuditRecord.containsKey(jsonField)) {
 518                                 assertTrue("Audit field " + jsonField + ": expected null, actual " + actualAuditRecord.get(jsonField),
 519                                                 actualAuditRecord.get(jsonField).toString().equals("null")
 520                                                                 || actualAuditRecord.get(jsonField).toString().equals(Constants.EMPTY_STRING));
 521                         }
 522
 523                 } else {
 524                         assertTrue("Audit field " + jsonField + " not found in actual", actualAuditRecord.containsKey(jsonField));
 525                         Object foundValue = actualAuditRecord.get(jsonField);
 526                         compareElements(expectedValue, foundValue);
 527                 }
 528         }
 529
 530         public static void compareElements(Object expectedValue, Object foundValue) {
 531                 if (expectedValue instanceof String) {
 532                         assertTrue("Actual value " + foundValue + " is not string", foundValue instanceof String);
 533                         assertTrue("Expected " + "[" + expectedValue +"]" + " not equal to actual [" + foundValue + "]", foundValue.equals(expectedValue));
 534                 }
 535                 /*
 536                  * else if( expectedValue instanceof Number){ assertTrue(foundValue
 537                  * instanceof Number); assertTrue(foundValue == expectedValue); }
 538                  */
 539                 else if (expectedValue instanceof Boolean) {
 540                         assertTrue(foundValue instanceof Boolean);
 541                         assertTrue(foundValue == expectedValue);
 542                 } else if (expectedValue instanceof Map) {
 543                         assertTrue(foundValue instanceof Map);
 544                         Map<String, Object> foundMap = (Map<String, Object>) foundValue;
 545                         Map<String, Object> excpectedMap = (Map<String, Object>) expectedValue;
 546                         assertTrue("size of maps is not equel", foundMap.size() == excpectedMap.size());
 547                         Iterator<String> foundkeyItr = foundMap.keySet().iterator();
 548                         while (foundkeyItr.hasNext()) {
 549                                 String foundKey = foundkeyItr.next();
 550                                 assertTrue(excpectedMap.containsKey(foundKey));
 551                                 compareElements(excpectedMap.get(foundKey), foundMap.get(foundKey));
 552                         }
 553
 554                 } else if (expectedValue instanceof List) {
 555                         assertTrue(foundValue instanceof List);
 556                         List<Object> foundList = (List<Object>) foundValue;
 557                         List<Object> excpectedList = (List<Object>) expectedValue;
 558                         assertTrue("size of maps is not equel", foundList.size() == excpectedList.size());
 559             if( foundList.size() > 0 ){
 560                 final Object elementInList = foundList.get(0);
 561                 if( !(elementInList instanceof List || elementInList instanceof Map) ){
 562                        List<Object> tempList = new ArrayList<>();
 563                        tempList.addAll(foundList);
 564                        for(Object expectedObj : excpectedList){
 565                               if( tempList.contains(expectedObj)){
 566                                      tempList.remove(expectedObj);
 567                               }
 568                               else{
 569                                   assertTrue(false);
 570                               }
 571                        }
 572                        assertTrue("Lists are not equel", tempList.isEmpty());
 573                 }
 574             }
 575
 576                 } else {
 577                         assertTrue(foundValue.equals(expectedValue));
 578                 }
 579         }
 580
 581         // public static Map<String, Object> parseAuditResourceByAction(String
 582         // action, String body) throws Exception {
 583         //
 584         // Map auditingMessage = null;
 585         // auditingMessage = retrieveAuditMessagesByPattern(action, null);
 586         //
 587         // return auditingMessage;
 588         //
 589         // }
 590
 591         public static Map<String, Object> parseAuditResourceByAction(String action, Map<AuditingFieldsKey, String> body) throws Exception {
 592
 593                 Map auditingMessage = null;
 594                 auditingMessage = retrieveAuditMessagesByPattern(action, body, false);
 595                 return auditingMessage;
 596
 597         }
 598
 599         public static List<Map<String, Object>> parseAuditResourceByActionToList(String action,
 600                         Map<AuditingFieldsKey, String> body) throws Exception {
 601
 602                 Map auditingMessage = null;
 603
 604                 if (body == null || body.isEmpty()) {
 605                         auditingMessage = retrieveAuditMessagesByPattern(action, null, false);
 606                 } else {
 607                         auditingMessage = retrieveAuditMessagesByPattern(action, body, false);
 608                 }
 609
 610                 return ResponseParser.getAuditFromMessage(auditingMessage);
 611         }
 612
 613         public JSONObject buildElasticQueryStringObject(String defaultField, String queryValue) throws JSONException {
 614
 615                 JSONObject query_string = new JSONObject();
 616                 JSONObject jSONObject = new JSONObject();
 617                 jSONObject.put("default_field", defaultField);
 618                 jSONObject.put("query", queryValue);
 619
 620                 query_string.put("query_string", jSONObject);
 621
 622                 return query_string;
 623         }
 624
 625         public static JSONObject buildElasticQueryBody(List<JSONObject> listObjects) throws JSONException {
 626
 627                 JSONObject query = new JSONObject();
 628                 JSONObject bool = new JSONObject();
 629                 JSONObject must = new JSONObject();
 630                 JSONArray mustA = new JSONArray();
 631
 632                 for (int i = 0; i < listObjects.size(); i++) {
 633                         JSONObject match = new JSONObject();
 634                         match.put("match", listObjects.get(i));
 635                         mustA.put(match);
 636
 637                 }
 638
 639                 must.put("must", mustA);
 640                 bool.put("bool", must);
 641                 query.put("query", bool);
 642
 643                 return query;
 644         }
 645
 646         public static String retrieveAuditMessagesUsingBody(String query_string) throws IOException {
 647
 648                 Config config = Utils.getConfig();
 649                 HttpRequest getAuditingMessage = new HttpRequest();
 650                 Map<String, String> headersMap = new HashMap<String, String>();
 651                 String body = query_string;
 652
 653                 String url = String.format(Urls.GET_SEARCH_DATA_FROM_ES, config.getEsHost(), config.getEsPort(), "_search");
 654                 RestResponse restResponse = getAuditingMessage.httpSendPost(url, body, headersMap);
 655
 656                 return restResponse.getResponse();
 657         }
 658
 659         public static Map<String, String> retrieveAuditMessagesByPattern(String action, Map<AuditingFieldsKey, String> body, Boolean retryFlag)
 660                         throws IOException {
 661
 662                 // get cassandra table name by action
 663                 String esType = AuditingActionEnum.fromName(action).getAuditingEsType();
 664                 Map<String, String> resultsMap = new HashMap<String, String>();
 665
 666                 List<Pair<AuditingFieldsKey, String>> myFields = new ArrayList<Pair<AuditingFieldsKey, String>>();
 667                 Pair<AuditingFieldsKey, String> myPair = new Pair<AuditingFieldsKey, String>(
 668                                 AuditingFieldsKey.AUDIT_ACTION, action);
 669                 myFields.add(0, myPair);
 670                 if (body != null && !body.isEmpty()) {
 671                         for (Map.Entry<AuditingFieldsKey, String> mapElement : body.entrySet()) {
 672                                 myFields.add(new Pair<AuditingFieldsKey, String>(mapElement.getKey(), mapElement.getValue()));
 673                         }
 674                 }
 675
 676                 List<Row> fetchFromTable = CassandraUtils.fetchFromTable(auditKeySpaceName, esType, myFields);
 677                 if(retryFlag){
 678                         if(fetchFromTable.size() == 0){
 679                                 return resultsMap;
 680                         }
 681                 }
 682 //              assertTrue("expected on fetching from data base one record only, actual: " + fetchFromTable.size(), fetchFromTable.size() == 1);
 683
 684
 685
 686
 687                 Row row =null;
 688
 689                 if (fetchFromTable.size() > 1){
 690                         List<Row> fetchFromTable2 = fetchFromTable;
 691                         fetchFromTable2.sort((p1, p2) -> p1.getTimestamp(1).compareTo(p2.getTimestamp(1)));
 692                         row = fetchFromTable2.get(fetchFromTable2.size() - 1);
 693                 }
 694                 else {row = fetchFromTable.get(0);}
 695
 696                 ColumnDefinitions columnDefinitions = row.getColumnDefinitions();
 697
 698                 for (int i = 0; i < columnDefinitions.size(); i++) {
 699                         resultsMap.put(columnDefinitions.getName(i), row.getObject(columnDefinitions.getName(i)) == null ? "null"
 700                                         : row.getObject(columnDefinitions.getName(i)).toString());
 701                 }
 702
 703                 return resultsMap;
 704         }
 705
 706         public static void categoryAuditSuccess(String action, CategoryDefinition categoryDefinition, User user, int status,
 707                         String resourceType) throws Exception {
 708                 categoryAuditSuccessInternal(action, categoryDefinition, null, null, user, status, resourceType);
 709         }
 710
 711         public static void categoryAuditFailure(String action, CategoryDefinition categoryDataDefinition, User user,
 712                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 713                 categoryAuditFailureInternal(action, categoryDataDefinition, null, null, user, errorMessage, status,
 714                                 resourceType, variables);
 715         }
 716
 717         public static void subCategoryAuditSuccess(String action, CategoryDefinition categoryDefinition,
 718                         SubCategoryDefinition subCategoryDefinition, User user, int status, String resourceType) throws Exception {
 719                 categoryAuditSuccessInternal(action, categoryDefinition, subCategoryDefinition, null, user, status,
 720                                 resourceType);
 721         }
 722
 723         public static void groupingAuditSuccess(String action, CategoryDefinition categoryDefinition,
 724                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user, int status,
 725                         String resourceType) throws Exception {
 726                 categoryAuditSuccessInternal(action, categoryDefinition, subCategoryDefinition, groupingDefinition, user,
 727                                 status, resourceType);
 728         }
 729
 730         public static void subCategoryAuditFailure(String action, CategoryDefinition categoryDataDefinition,
 731                         SubCategoryDefinition subCategoryDefinition, User user, ActionStatus errorMessage, int status,
 732                         String resourceType, Object... variables) throws Exception {
 733                 categoryAuditFailureInternal(action, categoryDataDefinition, subCategoryDefinition, null, user, errorMessage,
 734                                 status, resourceType, variables);
 735         }
 736
 737         // NEW Benny
 738         public static void groupingAuditFailure(String action, CategoryDefinition categoryDefinition,
 739                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user,
 740                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 741                 groupingAuditFailureInternal(action, categoryDefinition, subCategoryDefinition, groupingDefinition, user,
 742                                 errorMessage, status, resourceType, variables);
 743         }
 744
 745         private static void groupingAuditFailureInternal(String action, CategoryDefinition categoryDataDefinition,
 746                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user,
 747                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 748                 // validate audit
 749                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 750                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
 751                 expectedCatrgoryAuditJavaObject.setAction(action);
 752                 expectedCatrgoryAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 753                 expectedCatrgoryAuditJavaObject.setCategoryName(categoryDataDefinition.getName());
 754                 String subCategoryName = (subCategoryDefinition != null ? subCategoryDefinition.getName() : Constants.EMPTY_STRING);
 755                 expectedCatrgoryAuditJavaObject.setSubCategoryName(subCategoryName);
 756                 String groupingName = (groupingDefinition != null ? groupingDefinition.getName() : Constants.EMPTY_STRING);
 757                 expectedCatrgoryAuditJavaObject.setGroupingName(groupingName);
 758                 expectedCatrgoryAuditJavaObject.setResourceType(resourceType);
 759                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(status));
 760                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 761                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, action);
 762         }
 763
 764         ///
 765         private static void categoryAuditSuccessInternal(String action, CategoryDefinition categoryDefinition,
 766                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user, int status,
 767                         String resourceType) throws Exception {
 768                 // resourceType = Service/Resource/Product
 769                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
 770                 expectedCatrgoryAuditJavaObject.setAction(action);
 771                 expectedCatrgoryAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 772                 expectedCatrgoryAuditJavaObject.setCategoryName(categoryDefinition.getName());
 773                 String subCategoryName = (subCategoryDefinition != null ? subCategoryDefinition.getName()
 774                                 : Constants.EMPTY_STRING);
 775                 expectedCatrgoryAuditJavaObject.setSubCategoryName(subCategoryName);
 776                 String groupingName = (groupingDefinition != null ? groupingDefinition.getName() : Constants.EMPTY_STRING);
 777                 expectedCatrgoryAuditJavaObject.setGroupingName(groupingName);
 778                 expectedCatrgoryAuditJavaObject.setResourceType(resourceType);
 779                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(status));
 780                 expectedCatrgoryAuditJavaObject.setDesc("OK");
 781                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, action);
 782         }
 783
 784         ///////////////////////////
 785         ///// BENNNNNNNNY
 786         public enum UserAuditJsonKeysEnum {
 787                 ACTION("ACTION"), MODIFIER("MODIFIER"), STATUS("STATUS"), DESC("DESCRIPTION"), USER_AFTER("USER_AFTER"), USER_BEFORE("USER_BEFORE");
 788                 private String auditJsonKeyName;
 789
 790                 private UserAuditJsonKeysEnum(String auditJsonKeyName) {
 791                         this.auditJsonKeyName = auditJsonKeyName;
 792                 }
 793
 794                 public String getAuditJsonKeyName() {
 795                         return auditJsonKeyName.toLowerCase();
 796                 }
 797         }
 798
 799         public static void validateAddUserAudit(ExpectedUserCRUDAudit expectedAddUserAuditJavaObject, String action) throws Exception {
 800
 801                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedAddUserAuditJavaObject.getAction(), 1);
 802                 Map<String, Object> map = actionToList.get(0);
 803                 validateField(map, UserAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 804                 validateField(map, UserAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedAddUserAuditJavaObject.getModifier());
 805                 validateField(map, UserAuditJsonKeysEnum.USER_AFTER.getAuditJsonKeyName(), expectedAddUserAuditJavaObject.getUserAfter());
 806                 validateField(map, UserAuditJsonKeysEnum.USER_BEFORE.getAuditJsonKeyName(), expectedAddUserAuditJavaObject.getUserBefore());
 807                 validateField(map, UserAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedAddUserAuditJavaObject.getStatus());
 808                 validateField(map, UserAuditJsonKeysEnum.DESC.getAuditJsonKeyName(), expectedAddUserAuditJavaObject.getDesc());
 809
 810         }
 811
 812         private static void categoryAuditFailureInternal(String action, CategoryDefinition categoryDataDefinition,
 813                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user,
 814                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 815                 // validate audit
 816                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 817                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
 818                 expectedCatrgoryAuditJavaObject.setAction(action);
 819                 expectedCatrgoryAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 820                 expectedCatrgoryAuditJavaObject.setCategoryName(categoryDataDefinition.getName());
 821                 String subCategoryName = (subCategoryDefinition != null ? subCategoryDefinition.getName() : Constants.EMPTY_STRING);
 822                 expectedCatrgoryAuditJavaObject.setSubCategoryName(subCategoryName);
 823                 String groupingName = (groupingDefinition != null ? groupingDefinition.getName() : Constants.EMPTY_STRING);
 824                 expectedCatrgoryAuditJavaObject.setGroupingName(groupingName);
 825                 expectedCatrgoryAuditJavaObject.setResourceType(resourceType);
 826                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(status));
 827                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 828                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, action);
 829         }
 830
 831         public static void validateGetCategoryHirarchy(ExpectedCategoryAudit expectedCatrgoryAuditJavaObject, String action)
 832                         throws Exception {
 833
 834                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedCatrgoryAuditJavaObject.getAction(), 1);
 835                 Map<String, Object> map = actionToList.get(0);
 836
 837                 expectedCatrgoryAuditJavaObject.setModifier(getModifierString(expectedCatrgoryAuditJavaObject.getModifierName(),
 838                                 expectedCatrgoryAuditJavaObject.getModifierUid()));
 839                 validateField(map, CategoryAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 840                 validateField(map, CategoryAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getModifier());
 841                 validateField(map, CategoryAuditJsonKeysEnum.DETAILS.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getDetails());
 842                 validateField(map, CategoryAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getStatus());
 843                 validateField(map, CategoryAuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getDesc());
 844
 845         }
 846
 847         public static void validateCategoryAudit(ExpectedCategoryAudit expectedCatrgoryAuditJavaObject, String action)
 848                         throws Exception {
 849
 850                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedCatrgoryAuditJavaObject.getAction(), 1);
 851                 Map<String, Object> map = actionToList.get(0);
 852                 validateField(map, CategoryAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 853                 validateField(map, CategoryAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getModifier());
 854                 validateField(map, CategoryAuditJsonKeysEnum.CATEGORY_NAME.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getCategoryName());
 855                 validateField(map, CategoryAuditJsonKeysEnum.SUB_CATEGORY_NAME.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getSubCategoryName());
 856                 validateField(map, CategoryAuditJsonKeysEnum.GROUPING_NAME.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getGroupingName());
 857                 validateField(map, CategoryAuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getResourceType());
 858                 validateField(map, CategoryAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getStatus());
 859                 validateField(map, CategoryAuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedCatrgoryAuditJavaObject.getDesc());
 860         }
 861
 862         public static void GetCategoryHierarchyAuditSuccess(String action, String componentType, User user, int status)
 863                         throws Exception {
 864                 ExpectedGetUserListAudit expectedGetListOfUsersAuditJavaObject = new ExpectedGetUserListAudit();
 865                 expectedGetListOfUsersAuditJavaObject.setAction(action);
 866                 expectedGetListOfUsersAuditJavaObject.setStatus(String.valueOf(status));
 867                 expectedGetListOfUsersAuditJavaObject.setDesc("OK");
 868                 expectedGetListOfUsersAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 869                 expectedGetListOfUsersAuditJavaObject.setDetails(componentType.toLowerCase());
 870                 validateAuditGetListOfUsersByRoles(expectedGetListOfUsersAuditJavaObject, action);
 871         }
 872
 873         public static String buildArtifactDataAudit(ArtifactDefinition artifactDefinition) {
 874                 StringBuilder sb = new StringBuilder();
 875                 if (artifactDefinition.getTimeout() == null) {
 876                         artifactDefinition.setTimeout(0);
 877                 }
 878                 if (artifactDefinition != null) {
 879                         sb.append(artifactDefinition.getArtifactGroupType() == null ? null
 880                                         : artifactDefinition.getArtifactGroupType().getType()).append(",").append("'")
 881                                         .append(artifactDefinition.getArtifactLabel()).append("'").append(",")
 882                                         .append(artifactDefinition.getArtifactType()).append(",")
 883                                         .append(artifactDefinition.getArtifactName()).append(",").append(artifactDefinition.getTimeout())
 884                                         .append(",").append(artifactDefinition.getEsId());
 885                         sb.append(",");
 886                         if (artifactDefinition.getArtifactVersion() != null) {
 887                                 sb.append(artifactDefinition.getArtifactVersion());
 888                         } else {
 889                                 sb.append(" ");
 890                         }
 891                         sb.append(",");
 892                         if (artifactDefinition.getArtifactUUID() != null) {
 893                                 sb.append(artifactDefinition.getArtifactUUID());
 894                         } else {
 895                                 sb.append(" ");
 896                         }
 897                 }
 898
 899                 return sb.toString();
 900         }
 901
 902
 903         public static ExpectedResourceAuditJavaObject expectedArtifactNotFoundAuditObject(String Action, String resourceUid,
 904                                                                                       ComponentType resourceType, String artifactUid, User user, String currState, String currVersion)
 905                         throws FileNotFoundException {
 906                 String desc = null;
 907
 908                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
 909                 expectedAudit.setAction(Action);
 910                 expectedAudit.setResourceName(resourceUid);
 911                 expectedAudit.setResourceType(resourceType.getValue());
 912                 expectedAudit.setPrevVersion("");
 913                 expectedAudit.setCurrVersion(currVersion);
 914                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
 915                 expectedAudit.setModifierUid(user.getUserId());
 916                 expectedAudit.setPrevState("");
 917                 expectedAudit.setCurrState(currState);
 918                 expectedAudit.setPrevArtifactUuid("");
 919                 expectedAudit.setCurrArtifactUuid(artifactUid);
 920                 expectedAudit.setArtifactData("");
 921                 expectedAudit.setStatus("404");
 922
 923                 desc = buildAuditDescription(
 924                                 new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name()),
 925                                 Arrays.asList(""));
 926
 927                 expectedAudit.setDesc(desc);
 928                 return expectedAudit;
 929         }
 930
 931         public static JSONObject filterAuditByUuid(String action, String uuid) throws Exception {
 932                 Map<String, String> actionMap = new HashMap<>();
 933                 actionMap.put("ACTION", action);
 934                 JSONObject actionJsonObject = new JSONObject(actionMap);
 935                 Map<String, String> uuidMap = new HashMap<>();
 936                 uuidMap.put("SERVICE_INSTANCE_ID", uuid);
 937                 JSONObject uuidJsonObject = new JSONObject(uuidMap);
 938
 939                 List<JSONObject> filters = new ArrayList<>(Arrays.asList(actionJsonObject, uuidJsonObject));
 940                 JSONObject body = buildElasticQueryBody(filters);
 941                 return body;
 942         }
 943
 944         public static void validateAudit(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action) throws Exception {
 945                 List<Map<String, Object>> actionToList = getAuditListByAction(resourceAuditJavaObject.getAction(), 1);
 946                 Map<String, Object> map2 = actionToList.get(0);
 947                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 948                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceName());
 949                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), resourceAuditJavaObject.getResourceType());
 950                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevVersion());
 951                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrVersion());
 952                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getMODIFIER());
 953                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevState());
 954                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 955                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 956                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 957                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
 958         }
 959
 960         ////// service audit validation/////////////////////
 961
 962         public static ExpectedResourceAuditJavaObject constructFieldsForAuditValidation(ServiceReqDetails serviceReqDetails,
 963                         String serviceVersion, User sdncUserDetails) {
 964
 965                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
 966
 967                 expectedResourceAuditJavaObject.setAction("Create");
 968                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
 969                 String userFirstLastName = sdncUserDetails.getFirstName() + " " + sdncUserDetails.getLastName();
 970                 expectedResourceAuditJavaObject.setModifierName(userFirstLastName);
 971                 expectedResourceAuditJavaObject.setStatus("200");
 972                 expectedResourceAuditJavaObject.setDesc("OK");
 973                 expectedResourceAuditJavaObject.setResourceName(serviceReqDetails.getName());
 974                 expectedResourceAuditJavaObject.setResourceType("Service");
 975                 expectedResourceAuditJavaObject.setPrevVersion(String.valueOf(Float.parseFloat(serviceVersion) - 0.1f));
 976                 expectedResourceAuditJavaObject.setCurrVersion(serviceVersion);
 977                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 978                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 979                 expectedResourceAuditJavaObject.setComment(null);
 980
 981                 return expectedResourceAuditJavaObject;
 982
 983         }
 984
 985         public static ExpectedResourceAuditJavaObject constructFieldsForAuditValidation(ServiceReqDetails serviceReqDetails,
 986                         String serviceVersion, User sdncUserDetails, ActionStatus errorStatus, List<String> variables)
 987                         throws FileNotFoundException {
 988
 989                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = constructFieldsForAuditValidation(
 990                                 serviceReqDetails, serviceVersion, sdncUserDetails);
 991                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorStatus.name());
 992
 993                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 994                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 995                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 996
 997                 return expectedResourceAuditJavaObject;
 998
 999         }
1000
1001 }