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