test-apis-ci/src/main/java/org/openecomp/sdc/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.openecomp.sdc.ci.tests.utils.validation;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertTrue;
  25
  26 import java.io.FileNotFoundException;
  27 import java.io.IOException;
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.List;
  33 import java.util.Map;
  34
  35 import org.apache.log4j.Logger;
  36 import org.codehaus.jettison.json.JSONArray;
  37 import org.codehaus.jettison.json.JSONException;
  38 import org.codehaus.jettison.json.JSONObject;
  39 import org.javatuples.Pair;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.datatypes.elements.ConsumerDataDefinition;
  42 import org.openecomp.sdc.be.model.ArtifactDefinition;
  43 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  44 import org.openecomp.sdc.be.model.User;
  45 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  46 import org.openecomp.sdc.be.model.category.GroupingDefinition;
  47 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  48 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  49 import org.openecomp.sdc.ci.tests.api.Urls;
  50 import org.openecomp.sdc.ci.tests.config.Config;
  51 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  52 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.AuditEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.enums.AuditJsonKeysEnum;
  55 import org.openecomp.sdc.ci.tests.datatypes.enums.ComponentType;
  56 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  57 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedAuthenticationAudit;
  58 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedCategoryAudit;
  59 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedDistDownloadAudit;
  60 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedEcomConsumerAudit;
  61 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedExternalAudit;
  62 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedGetUserListAudit;
  63 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedProductAudit;
  64 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  65 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedUserCRUDAudit;
  66 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  67 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  68 import org.openecomp.sdc.ci.tests.run.StartTest;
  69 import org.openecomp.sdc.ci.tests.utils.ArtifactUtils;
  70 import org.openecomp.sdc.ci.tests.utils.Utils;
  71 import org.openecomp.sdc.ci.tests.utils.cassandra.CassandraUtils;
  72 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  73 import org.openecomp.sdc.ci.tests.utils.rest.CategoryRestUtils.CategoryAuditJsonKeysEnum;
  74 import org.openecomp.sdc.ci.tests.utils.rest.ConsumerRestUtils.EcompConsumerAuditJsonKeysEnum;
  75 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  76 import org.openecomp.sdc.common.api.Constants;
  77 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  78
  79 import com.datastax.driver.core.ColumnDefinitions;
  80 import com.datastax.driver.core.Row;
  81
  82 public class AuditValidationUtils {
  83         protected static Logger logger = Logger.getLogger(AuditValidationUtils.class.getName());
  84         private static final String auditKeySpaceName = "sdcaudit";
  85
  86         public AuditValidationUtils() {
  87                 super();
  88
  89                 StartTest.enableLogger();
  90                 logger = Logger.getLogger(AuditValidationUtils.class.getName());
  91
  92         }
  93
  94         public static String buildAuditDescription(ErrorInfo errorInfo, List<String> variables) {
  95
  96                 String auditDesc = errorInfo.getMessageId() + ": " + errorInfo.getMessage();
  97                 if(! variables.isEmpty() && variables.get(0) != null && ! variables.get(0).isEmpty()){
  98                         for (int i = 0; i < variables.size(); i++) {
  99                                 if (auditDesc.contains("%" + (i + 1))) {
 100                                         auditDesc = auditDesc.replace("%" + (i + 1), variables.get(i));
 101                                 }
 102                         }
 103                 }
 104                 return auditDesc;
 105         }
 106
 107         public static String getModifierString(String userName, String uid) {
 108
 109                 if (userName.isEmpty() && uid.isEmpty())
 110                         return "(UNKNOWN)";
 111
 112                 StringBuilder sb = new StringBuilder();
 113                 sb.append(userName).append("(").append(uid).append(")");
 114                 return sb.toString();
 115
 116         }
 117
 118         public static void validateAuditDownloadExternalAPI(ExpectedResourceAuditJavaObject resourceAuditJavaObject,
 119                         String action, String body, boolean checkAllFields) throws Exception {
 120                 Map<String, Object> actualAuditRecords = new HashMap<String, Object>();
 121                 // Andrey's comment
 122                 // actualAuditRecords = parseAuditResourceByAction(action, body);
 123                 actualAuditRecords = parseAuditResourceByAction(action, null);
 124
 125                 // List<Map<String, Object>> actualAuditRecords = new
 126                 // ArrayList<Map<String, Object>>();
 127                 // actualAuditRecords = parseAuditResourceByActionToList(action, body);
 128
 129                 validateField(actualAuditRecords, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 130                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 131                                 resourceAuditJavaObject.getResourceName());
 132                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 133                                 resourceAuditJavaObject.getResourceType());
 134
 135                 validateField(actualAuditRecords, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
 136                                 resourceAuditJavaObject.getStatus());
 137                 validateField(actualAuditRecords, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(),
 138                                 resourceAuditJavaObject.getDesc());
 139
 140                 // validateField(actualAuditRecords,
 141                 // AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(),
 142                 // resourceAuditJavaObject.getCONSUMER_ID());
 143                 // validateField(actualAuditRecords,
 144                 // AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(),
 145                 // resourceAuditJavaObject.getRESOURCE_URL());
 146
 147         }
 148
 149         public static void validateAudit(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action,
 150                         String body, boolean checkAllFields) throws Exception {
 151                 Map<String, Object> actualAuditRecords = new HashMap<String, Object>();
 152                 // Andrey's comment
 153                 // actualAuditRecords = parseAuditResourceByAction(action, body);
 154                 actualAuditRecords = parseAuditResourceByAction(action, null);
 155
 156                 if ((resourceAuditJavaObject.getModifierName() != null) && (resourceAuditJavaObject.getModifierUid() != null)) {
 157                         resourceAuditJavaObject.setModifierUid(getModifierString(resourceAuditJavaObject.getModifierName(),
 158                                         resourceAuditJavaObject.getModifierUid()));
 159                 }
 160
 161                 validateField(actualAuditRecords, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 162                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 163                                 resourceAuditJavaObject.getResourceName());
 164                 validateField(actualAuditRecords, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 165                                 resourceAuditJavaObject.getResourceType());
 166                 validateField(actualAuditRecords, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(),
 167                                 resourceAuditJavaObject.getPrevVersion());
 168                 validateField(actualAuditRecords, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 169                                 resourceAuditJavaObject.getCurrVersion());
 170
 171                 validateField(actualAuditRecords, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
 172                                 resourceAuditJavaObject.getModifierUid());
 173                 validateField(actualAuditRecords, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(),
 174                                 resourceAuditJavaObject.getPrevState());
 175                 validateField(actualAuditRecords, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(),
 176                                 resourceAuditJavaObject.getCurrState());
 177                 validateField(actualAuditRecords, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
 178                                 resourceAuditJavaObject.getStatus());
 179                 // validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
 180                 // Double.parseDouble(resourceAuditJavaObject.getStatus()));
 181                 validateField(actualAuditRecords, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(),
 182                                 resourceAuditJavaObject.getDesc());
 183                 validateField(actualAuditRecords, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(),
 184                                 resourceAuditJavaObject.getComment());
 185                 // validateField(map2,
 186                 // AuditJsonKeysEnum.ARTIFACT_DATA.getAuditJsonKeyName(),
 187                 // resourceAuditJavaObject.getArtifactData());
 188                 validateField(actualAuditRecords, AuditJsonKeysEnum.TOSCA_NODE_TYPE.getAuditJsonKeyName(),
 189                                 resourceAuditJavaObject.getToscaNodeType());
 190                 validateField(actualAuditRecords, AuditJsonKeysEnum.CURR_ARTIFACT_UUID.getAuditJsonKeyName(),
 191                                 resourceAuditJavaObject.getCurrArtifactUuid());
 192                 validateField(actualAuditRecords, AuditJsonKeysEnum.PREV_ARTIFACT_UUID.getAuditJsonKeyName(),
 193                                 resourceAuditJavaObject.getPrevArtifactUuid());
 194
 195                 validateAtifactDataField(actualAuditRecords, AuditJsonKeysEnum.ARTIFACT_DATA.getAuditJsonKeyName(),
 196                                 resourceAuditJavaObject.getArtifactData(), checkAllFields);
 197         }
 198
 199         public static void validateExternalAudit(ExpectedExternalAudit externalAuditObject, String action,
 200                         Map<AuditingFieldsKeysEnum, String> body) throws Exception {
 201
 202                 Map<String, Object> actualAuditRecord = new HashMap<String, Object>();
 203                 actualAuditRecord = parseAuditResourceByAction(action, body);
 204
 205                 validateField(actualAuditRecord, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 206                 validateField(actualAuditRecord, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(),
 207                                 externalAuditObject.getCONSUMER_ID());
 208                 // TODO
 209                 validateField(actualAuditRecord, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(),
 210                                 externalAuditObject.getRESOURCE_URL());
 211                 //TODO
 212                 validateField(actualAuditRecord, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 213                                 externalAuditObject.getRESOURCE_NAME());
 214                 validateField(actualAuditRecord, AuditJsonKeysEnum.SERVICE_INSTANCE_ID.getAuditJsonKeyName(),
 215                                 externalAuditObject.getSERVICE_INSTANCE_ID());
 216                 //TODO
 217                 validateField(actualAuditRecord, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 218                                 externalAuditObject.getRESOURCE_TYPE());
 219                 validateField(actualAuditRecord, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
 220                                 externalAuditObject.getSTATUS());
 221                 validateField(actualAuditRecord, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(),
 222                                 externalAuditObject.getDESC());
 223                 //TODO
 224 //              validateField(actualAuditRecord, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
 225 //                              externalAuditObject.getMODIFIER());
 226                 validateField(actualAuditRecord, AuditJsonKeysEnum.PREV_ARTIFACT_UUID.getAuditJsonKeyName(),
 227                                 externalAuditObject.getPREV_ARTIFACT_UUID());
 228                 validateField(actualAuditRecord, AuditJsonKeysEnum.CURR_ARTIFACT_UUID.getAuditJsonKeyName(),
 229                                 externalAuditObject.getCURR_ARTIFACT_UUID());
 230                 //TODO
 231                 validateField(actualAuditRecord, AuditJsonKeysEnum.ARTIFACT_DATA.getAuditJsonKeyName(),
 232                                 externalAuditObject.getARTIFACT_DATA());
 233
 234         }
 235
 236         public enum ArtifactDataFieldEnum {
 237                 attGroup, artLable, artType, artName, artTimeout, artPayloadUUID, artVersion, artUUID
 238         }
 239
 240         private static void validateAtifactDataField(Map<String, Object> map, String auditJsonKeyName,
 241                         String expectedArtifactData, boolean checkAllFields) {
 242                 Map<ArtifactDataFieldEnum, String> expectedArtifactDataFileds = new HashMap<ArtifactDataFieldEnum, String>();
 243                 Map<ArtifactDataFieldEnum, String> actualAtifactDataFileds = new HashMap<ArtifactDataFieldEnum, String>();
 244                 if (expectedArtifactData != null) {
 245                         String[] expected = expectedArtifactData.split(",");
 246
 247                         assertTrue("Audit field " + auditJsonKeyName + " not found", map.containsKey(auditJsonKeyName));
 248                         String actualValue = (String) map.get(auditJsonKeyName);
 249                         String[] actual = actualValue.split(",");
 250
 251                         if (expected.length == 1 && actual.length == 1) {
 252                                 assertEquals(expectedArtifactData, actualValue);
 253                                 return;
 254                         }
 255
 256                         assertEquals(ArtifactDataFieldEnum.values().length, expected.length);
 257                         assertEquals(ArtifactDataFieldEnum.values().length, actual.length);
 258
 259                         for (ArtifactDataFieldEnum field : ArtifactDataFieldEnum.values()) {
 260
 261                                 expectedArtifactDataFileds.put(field, expected[field.ordinal()]);
 262                                 actualAtifactDataFileds.put(field, actual[field.ordinal()]);
 263                         }
 264                         for (Map.Entry<ArtifactDataFieldEnum, String> entry : expectedArtifactDataFileds.entrySet()) {
 265                                 ArtifactDataFieldEnum field = entry.getKey();
 266                                 if (checkAllFields || (!field.equals(ArtifactDataFieldEnum.artVersion)
 267                                                 && !field.equals(ArtifactDataFieldEnum.artUUID))) {
 268                                         assertTrue("Audit field ArtifactData dosn't containt " + field,
 269                                                         actualAtifactDataFileds.containsKey(field));
 270                                         assertEquals("Audit field ArtifactData dosn't equal " + field,
 271                                                         expectedArtifactDataFileds.get(field), actualAtifactDataFileds.get(field));
 272                                 }
 273
 274                         }
 275                 }
 276         }
 277
 278         // //Benny
 279         public static void validateEcompConsumerAudit(ExpectedEcomConsumerAudit ecompConsumerAuditJavaObject, String action)
 280                         throws Exception {
 281
 282                 String fixedAction = BaseRestUtils.encodeUrlForDownload(action);
 283                 Map<String, Object> map2 = new HashMap<String, Object>();
 284                 map2 = parseAuditResourceByAction(fixedAction, null);
 285
 286                 validateField(map2, EcompConsumerAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
 287                                 ecompConsumerAuditJavaObject.getModifier());
 288                 validateField(map2, EcompConsumerAuditJsonKeysEnum.ECOMP_USER.getAuditJsonKeyName(),
 289                                 ecompConsumerAuditJavaObject.getEcomUser());
 290                 validateField(map2, EcompConsumerAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
 291                                 ecompConsumerAuditJavaObject.getStatus());
 292                 validateField(map2, EcompConsumerAuditJsonKeysEnum.DESC.getAuditJsonKeyName(),
 293                                 ecompConsumerAuditJavaObject.getDesc());
 294                 validateField(map2, EcompConsumerAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 295         }
 296
 297         public static void ecompConsumerAuditSuccess(String action, ConsumerDataDefinition consumerDataDefinition,
 298                         User user, int status) throws Exception {
 299                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 300                 expectedEcomConsumerAuditJavaObject.setAction(action);
 301                 expectedEcomConsumerAuditJavaObject.setEcomUser(
 302                                 consumerDataDefinition.getConsumerName() + "," + consumerDataDefinition.getConsumerSalt().toLowerCase()
 303                                                 + "," + consumerDataDefinition.getConsumerPassword().toLowerCase());
 304                 expectedEcomConsumerAuditJavaObject.setStatus(String.valueOf(status));
 305                 expectedEcomConsumerAuditJavaObject.setDesc("OK");
 306                 expectedEcomConsumerAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 307                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject, action);
 308         }
 309
 310         public static void createEcompConsumerAuditFailure(String action, ConsumerDataDefinition consumerDataDefinition,
 311                         User user, ActionStatus errorMessage, Object... variables) throws Exception {
 312                 // validate audit
 313                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 314                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 315                 expectedEcomConsumerAuditJavaObject.setAction(action);
 316                 expectedEcomConsumerAuditJavaObject.setEcomUser(
 317                                 consumerDataDefinition.getConsumerName() + "," + consumerDataDefinition.getConsumerSalt().toLowerCase()
 318                                                 + "," + consumerDataDefinition.getConsumerPassword().toLowerCase());
 319                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 320                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 321                 expectedEcomConsumerAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 322                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject, action);
 323         }
 324
 325         public static void deleteEcompConsumerAuditFailure(String action, ConsumerDataDefinition consumerDataDefinition,
 326                         User user, ActionStatus errorMessage, Object... variables) throws Exception {
 327                 // validate audit
 328                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 329                 ExpectedEcomConsumerAudit expectedEcomConsumerAuditJavaObject = new ExpectedEcomConsumerAudit();
 330                 // String auditAction = ADD_ECOMP_USER_CREDENTIALS_AUDIT_ACTION;
 331                 expectedEcomConsumerAuditJavaObject.setAction(action);
 332                 expectedEcomConsumerAuditJavaObject.setEcomUser(consumerDataDefinition.getConsumerName());
 333                 expectedEcomConsumerAuditJavaObject.setStatus(errorInfo.getCode().toString());
 334                 expectedEcomConsumerAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 335                 expectedEcomConsumerAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 336                 AuditValidationUtils.validateEcompConsumerAudit(expectedEcomConsumerAuditJavaObject, action);
 337         }
 338
 339         ////////////////////// US571255
 340         public static void GetListOfUsersByRolesAuditFailure(String action, String roles, int status, User userModifier,
 341                         ActionStatus errorMessage, Object... variables) throws Exception {
 342                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 343                 ExpectedGetUserListAudit expectedGetListOfUsersAuditJavaObject = new ExpectedGetUserListAudit(); // String
 344                                                                                                                                                                                                                         // auditAction
 345                                                                                                                                                                                                                         // =
 346                                                                                                                                                                                                                         // ADD_ECOMP_USER_CREDENTIALS_AUDIT_ACTION;
 347                 expectedGetListOfUsersAuditJavaObject.setAction(action);
 348                 expectedGetListOfUsersAuditJavaObject.setStatus(String.valueOf(status));
 349                 expectedGetListOfUsersAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 350
 351                 expectedGetListOfUsersAuditJavaObject.setDetails(roles);
 352                 if (errorMessage == ActionStatus.USER_INACTIVE || errorMessage == ActionStatus.MISSING_INFORMATION) {
 353                         expectedGetListOfUsersAuditJavaObject.setModifier("(UNKNOWN)");
 354                 } else {
 355                         expectedGetListOfUsersAuditJavaObject
 356                                         .setModifier(userModifier.getFullName() + "(" + userModifier.getUserId() + ")");
 357                 }
 358                 AuditValidationUtils.validateAuditGetListOfUsersByRoles(expectedGetListOfUsersAuditJavaObject, action);
 359         }
 360
 361         public static void GetListOfUsersByRolesAuditSuccess(String action, String roles, User user, int status)
 362                         throws Exception {
 363                 ExpectedGetUserListAudit expectedGetListOfUsersAuditJavaObject = new ExpectedGetUserListAudit();
 364                 expectedGetListOfUsersAuditJavaObject.setAction(action);
 365                 expectedGetListOfUsersAuditJavaObject.setStatus(String.valueOf(status));
 366                 expectedGetListOfUsersAuditJavaObject.setDesc("OK");
 367                 expectedGetListOfUsersAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 368                 expectedGetListOfUsersAuditJavaObject.setDetails(roles);
 369                 validateAuditGetListOfUsersByRoles(expectedGetListOfUsersAuditJavaObject, action);
 370         }
 371
 372         public static void validateAuditGetListOfUsersByRoles(ExpectedGetUserListAudit GetListOfUsersAuditJavaObject,
 373                         String action) throws Exception {
 374
 375                 Map<String, Object> map2 = new HashMap<String, Object>();
 376                 map2 = parseAuditResourceByAction(action, null);
 377                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 378                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), GetListOfUsersAuditJavaObject.getStatus());
 379                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
 380                                 GetListOfUsersAuditJavaObject.getModifier());
 381                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(),
 382                                 GetListOfUsersAuditJavaObject.getDesc());
 383                 validateField(map2, AuditJsonKeysEnum.DETAILS.getAuditJsonKeyName(),
 384                                 GetListOfUsersAuditJavaObject.getDetails());
 385         }
 386
 387         public static void validateAuditImport(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action)
 388                         throws Exception {
 389
 390                 Map<String, Object> map2 = new HashMap<String, Object>();
 391                 map2 = parseAuditResourceByAction(action, null);
 392
 393                 resourceAuditJavaObject.setModifierUid(
 394                                 getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 395
 396                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 397                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 398                                 resourceAuditJavaObject.getResourceType());
 399                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(),
 400                                 resourceAuditJavaObject.getPrevVersion());
 401                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 402                                 resourceAuditJavaObject.getCurrVersion());
 403                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 404                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevState());
 405                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 406                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 407                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 408
 409         }
 410
 411         public static void validateAuditDistribution(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action)
 412                         throws Exception {
 413
 414                 Map<String, Object> map2 = new HashMap<String, Object>();
 415                 map2 = parseAuditResourceByAction(action, null);
 416
 417                 resourceAuditJavaObject.setModifierUid(
 418                                 getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 419
 420                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 421                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 422                                 resourceAuditJavaObject.getResourceName());
 423                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 424                                 resourceAuditJavaObject.getResourceType());
 425                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 426                                 resourceAuditJavaObject.getCurrVersion());
 427                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 428                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 429                 validateField(map2, AuditJsonKeysEnum.DPREV_STATUS.getAuditJsonKeyName(),
 430                                 resourceAuditJavaObject.getDprevStatus());
 431                 validateField(map2, AuditJsonKeysEnum.DCURR_STATUS.getAuditJsonKeyName(),
 432                                 resourceAuditJavaObject.getDcurrStatus());
 433                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 434                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 435                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
 436                 validateField(map2, AuditJsonKeysEnum.DID.getAuditJsonKeyName(), resourceAuditJavaObject.getDistributionId());
 437
 438         }
 439
 440         // Benny
 441         public static void validateAudit_Distribution(ExpectedResourceAuditJavaObject resourceAuditJavaObject,
 442                         String action) throws Exception {
 443
 444                 List<Map<String, Object>> actionToList = getAuditListByAction(resourceAuditJavaObject.getAction(), 1);
 445                 Map<String, Object> map2 = actionToList.get(0);
 446                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 447                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 448                                 resourceAuditJavaObject.getResourceName());
 449                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 450                                 resourceAuditJavaObject.getResourceType());
 451                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 452                                 resourceAuditJavaObject.getCurrVersion());
 453                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getMODIFIER());
 454                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 455                 validateField(map2, AuditJsonKeysEnum.DPREV_STATUS.getAuditJsonKeyName(),
 456                                 resourceAuditJavaObject.getDprevStatus());
 457                 validateField(map2, AuditJsonKeysEnum.DCURR_STATUS.getAuditJsonKeyName(),
 458                                 resourceAuditJavaObject.getDcurrStatus());
 459                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 460                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 461                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
 462
 463         }
 464
 465         public void validateAuditNotification(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action)
 466                         throws Exception {
 467
 468                 Map<String, Object> map2 = new HashMap<String, Object>();
 469                 map2 = parseAuditResourceByAction(action, null);
 470
 471                 resourceAuditJavaObject.setModifierUid(
 472                                 getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 473
 474                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 475                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 476                                 resourceAuditJavaObject.getResourceName());
 477                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 478                                 resourceAuditJavaObject.getResourceType());
 479                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 480                                 resourceAuditJavaObject.getCurrVersion());
 481                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
 482                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 483                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 484                 validateField(map2, AuditJsonKeysEnum.DID.getAuditJsonKeyName(), resourceAuditJavaObject.getDistributionId());
 485                 validateField(map2, AuditJsonKeysEnum.TOPIC_NAME.getAuditJsonKeyName(), resourceAuditJavaObject.getTopicName());
 486
 487         }
 488
 489         public static void validateAudit(ExpectedDistDownloadAudit expectedDistDownloadAudit, String action)
 490                         throws Exception {
 491
 492                 Map<String, Object> map2 = new HashMap<String, Object>();
 493                 map2 = parseAuditResourceByAction(action, null);
 494
 495                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 496                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedDistDownloadAudit.getStatus());
 497                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedDistDownloadAudit.getDesc());
 498                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(),
 499                                 expectedDistDownloadAudit.getConsumerId());
 500                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(),
 501                                 expectedDistDownloadAudit.getResourceUrl());
 502         }
 503
 504         public static void validateAuditExternalSearchAPI(ExpectedExternalAudit expectedDistDownloadAudit, String action, Map<AuditingFieldsKeysEnum, String> body)
 505                         throws Exception {
 506
 507                 Map<String, Object> map2 = new HashMap<String, Object>();
 508                 map2 = parseAuditResourceByAction(action, body);
 509
 510                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 511                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedDistDownloadAudit.getSTATUS());
 512                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedDistDownloadAudit.getDESC());
 513                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(),
 514                                 expectedDistDownloadAudit.getCONSUMER_ID());
 515                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(),
 516                                 expectedDistDownloadAudit.getRESOURCE_URL());
 517         }
 518
 519         public static void validateAuditExternalCreateResource(ExpectedResourceAuditJavaObject expectedExternalAudit, String action, Map<AuditingFieldsKeysEnum, String> body) throws Exception {
 520         Map<String, Object> map2 = new HashMap<String, Object>();
 521                 map2 = parseAuditResourceByAction(action, body);
 522
 523                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 524                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), expectedExternalAudit.getResourceName());
 525                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), expectedExternalAudit.getResourceType());
 526                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), expectedExternalAudit.getCONSUMER_ID());
 527                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), expectedExternalAudit.getRESOURCE_URL());
 528                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedExternalAudit.getMODIFIER());
 529
 530                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getPrevVersion());
 531                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getCurrVersion());
 532                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), expectedExternalAudit.getPrevState());
 533                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), expectedExternalAudit.getCurrState());
 534
 535                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedExternalAudit.getStatus());
 536                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedExternalAudit.getDesc());
 537         }
 538
 539         public static void validateAuditExternalChangeAssetLifeCycle(ExpectedResourceAuditJavaObject expectedExternalAudit, String action, Map<AuditingFieldsKeysEnum, String> body) throws Exception {
 540                 Map<String, Object> map2 = new HashMap<String, Object>();
 541                 map2 = parseAuditResourceByAction(action, body);
 542
 543                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 544                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), expectedExternalAudit.getDesc());
 545                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), expectedExternalAudit.getStatus());
 546
 547                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(), expectedExternalAudit.getResourceType());
 548                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(), expectedExternalAudit.getResourceName());
 549                 validateField(map2, AuditJsonKeysEnum.CONSUMER_ID.getAuditJsonKeyName(), expectedExternalAudit.getCONSUMER_ID());
 550                 validateField(map2, AuditJsonKeysEnum.RESOURCE_URL.getAuditJsonKeyName(), expectedExternalAudit.getRESOURCE_URL());
 551                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), expectedExternalAudit.getMODIFIER());
 552
 553                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getPrevVersion());
 554                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(), expectedExternalAudit.getCurrVersion());
 555                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), expectedExternalAudit.getPrevState());
 556                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), expectedExternalAudit.getCurrState());
 557
 558
 559                 // TODO: Remove comment
 560 //              validateField(map2, AuditJsonKeysEnum.INVARIANT_UUID.getAuditJsonKeyName(), expectedExternalAudit.getINVARIANT_UUID());
 561         }
 562
 563         public void validateAuditDeploy(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action)
 564                         throws Exception {
 565
 566                 Map<String, Object> map2 = new HashMap<String, Object>();
 567                 map2 = parseAuditResourceByAction(action, null);
 568
 569                 resourceAuditJavaObject.setModifierUid(
 570                                 getModifierString(resourceAuditJavaObject.getModifierName(), resourceAuditJavaObject.getModifierUid()));
 571
 572                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 573                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 574                                 resourceAuditJavaObject.getResourceName());
 575                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 576                                 resourceAuditJavaObject.getResourceType());
 577                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 578                                 resourceAuditJavaObject.getCurrVersion());
 579                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getModifierUid());
 580                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
 581                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
 582                 validateField(map2, AuditJsonKeysEnum.DID.getAuditJsonKeyName(), resourceAuditJavaObject.getDistributionId());
 583
 584         }
 585
 586         public static void validateAuditProduct(ExpectedProductAudit productExpectedAudit, String action,
 587                         AuditJsonKeysEnum... additionalFields) throws Exception {
 588
 589                 Map<String, Object> map2 = new HashMap<String, Object>();
 590                 map2 = parseAuditResourceByAction(action, null);
 591
 592                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
 593                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
 594                                 productExpectedAudit.getRESOURCE_NAME());
 595                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
 596                                 productExpectedAudit.getRESOURCE_TYPE());
 597                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(),
 598                                 productExpectedAudit.getPREV_VERSION());
 599                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
 600                                 productExpectedAudit.getCURR_VERSION());
 601                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), productExpectedAudit.getPREV_STATE());
 602                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), productExpectedAudit.getCURR_STATE());
 603                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), productExpectedAudit.getMODIFIER());
 604                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), productExpectedAudit.getSTATUS());
 605                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), productExpectedAudit.getDESC());
 606                 validateField(map2, AuditJsonKeysEnum.SERVICE_INSTANCE_ID.getAuditJsonKeyName(),
 607                                 productExpectedAudit.getSERVICE_INSTANCE_ID());
 608                 if (additionalFields != null) {
 609                         List<AuditJsonKeysEnum> fieldsList = Arrays.asList(additionalFields);
 610                         if (fieldsList.contains(AuditJsonKeysEnum.COMMENT)) {
 611                                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), productExpectedAudit.getCOMMENT());
 612                         }
 613                 }
 614         }
 615
 616         private static List<Map<String, Object>> getAuditListByAction(String action, int expectedNumOfAudit)
 617                         throws Exception {
 618                 List<Map<String, Object>> actionToList = parseAuditResourceByActionToList(action, null);
 619                 assertEquals("recieved different audits number than expected", expectedNumOfAudit, actionToList.size());
 620                 return actionToList;
 621         }
 622
 623         public static void validateAuthenticationAudit(ExpectedAuthenticationAudit expectedAudit) throws Exception {
 624                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedAudit.getAction(), 1);
 625                 assertEquals("expected number of ES action is 1", 1, actionToList.size());
 626
 627                 Map<String, Object> map = actionToList.get(0);
 628                 validateField(map, AuditEnum.ACTION.getValue(), expectedAudit.getAction());
 629                 validateField(map, AuditEnum.URL.getValue(), expectedAudit.getUrl());
 630                 validateField(map, AuditEnum.USER.getValue(), expectedAudit.getUser());
 631                 validateField(map, AuditEnum.AUTH_STATUS.getValue(), expectedAudit.getAuthStatus());
 632                 validateField(map, AuditEnum.REALM.getValue(), expectedAudit.getRealm());
 633
 634         }
 635
 636         private static void validateField(Map<String, Object> actualAuditRecord, String jsonField, Object expectedValue) {
 637                 if (expectedValue == null) {
 638                         // || changed to &&
 639                         if (actualAuditRecord.containsKey(jsonField)) {
 640                                 assertTrue("Audit field " + jsonField + ": expected null, actual " + actualAuditRecord.get(jsonField),
 641                                                 actualAuditRecord.get(jsonField).toString().equals("null")
 642                                                                 || actualAuditRecord.get(jsonField).toString().equals(Constants.EMPTY_STRING));
 643                         }
 644
 645                 } else {
 646                         assertTrue("Audit field " + jsonField + " not found in actual", actualAuditRecord.containsKey(jsonField));
 647                         Object foundValue = actualAuditRecord.get(jsonField);
 648                         compareElements(expectedValue, foundValue);
 649                 }
 650         }
 651
 652         public static void compareElements(Object expectedValue, Object foundValue) {
 653                 if (expectedValue instanceof String) {
 654                         assertTrue("Actual value " + foundValue + " is not string", foundValue instanceof String);
 655                         assertTrue("Expected " + expectedValue + " not equal to actual " + foundValue,
 656                                         foundValue.equals(expectedValue));
 657                 }
 658                 /*
 659                  * else if( expectedValue instanceof Number){ assertTrue(foundValue
 660                  * instanceof Number); assertTrue(foundValue == expectedValue); }
 661                  */
 662                 else if (expectedValue instanceof Boolean) {
 663                         assertTrue(foundValue instanceof Boolean);
 664                         assertTrue(foundValue == expectedValue);
 665                 } else if (expectedValue instanceof Map) {
 666                         assertTrue(foundValue instanceof Map);
 667                         Map<String, Object> foundMap = (Map<String, Object>) foundValue;
 668                         Map<String, Object> excpectedMap = (Map<String, Object>) expectedValue;
 669                         assertTrue("size of maps is not equel", foundMap.size() == excpectedMap.size());
 670                         Iterator<String> foundkeyItr = foundMap.keySet().iterator();
 671                         while (foundkeyItr.hasNext()) {
 672                                 String foundKey = foundkeyItr.next();
 673                                 assertTrue(excpectedMap.containsKey(foundKey));
 674                                 compareElements(excpectedMap.get(foundKey), foundMap.get(foundKey));
 675                         }
 676
 677                 } else if (expectedValue instanceof List) {
 678                         assertTrue(foundValue instanceof List);
 679                         List<Object> foundList = (List<Object>) foundValue;
 680                         List<Object> excpectedList = (List<Object>) expectedValue;
 681                         assertTrue("size of maps is not equel", foundList.size() == excpectedList.size());
 682             if( foundList.size() > 0 ){
 683                 final Object elementInList = foundList.get(0);
 684                 if( !(elementInList instanceof List || elementInList instanceof Map) ){
 685                        List<Object> tempList = new ArrayList<>();
 686                        tempList.addAll(foundList);
 687                        for(Object expectedObj : excpectedList){
 688                               if( tempList.contains(expectedObj)){
 689                                      tempList.remove(expectedObj);
 690                               }
 691                               else{
 692                                   assertTrue(false);
 693                               }
 694                        }
 695                        assertTrue("Lists are not equel", tempList.isEmpty());
 696                 }
 697             }
 698
 699                 } else {
 700                         assertTrue(foundValue.equals(expectedValue));
 701                 }
 702         }
 703
 704         // public static Map<String, Object> parseAuditResourceByAction(String
 705         // action, String body) throws Exception {
 706         //
 707         // Map auditingMessage = null;
 708         // auditingMessage = retrieveAuditMessagesByPattern(action, null);
 709         //
 710         // return auditingMessage;
 711         //
 712         // }
 713
 714         public static Map<String, Object> parseAuditResourceByAction(String action, Map<AuditingFieldsKeysEnum, String> body) throws Exception {
 715
 716                 Map auditingMessage = null;
 717                 auditingMessage = retrieveAuditMessagesByPattern(action, body, false);
 718
 719                 return auditingMessage;
 720
 721         }
 722
 723         // public static List<Map<String, Object>>
 724         // parseAuditResourceByActionToList(String action, String body) throws
 725         // Exception {
 726         //
 727         // List<Map<String, Object>> auditList = new ArrayList<Map<String,
 728         // Object>>();
 729         //
 730         //// String auditingMessage = null;
 731         //
 732         // Map auditingMessage = null;
 733         // auditingMessage = retrieveAuditMessagesByPattern(action);
 734         //
 735         // if (body == null) {
 736         //// String pattern = "/_search?q=ACTION:\"" + action + "\"";
 737         //// auditingMessage = retrieveAuditMessagesByPattern(action);
 738         //// auditingMessage = retrieveAuditMessagesByPattern(pattern);
 739         // } else {
 740         //// auditingMessage = retrieveAuditMessagesUsingBody(body);
 741         // }
 742         //
 743         // return ResponseParser.getAuditFromMessage(auditingMessage);
 744         //
 745         // }
 746
 747         public static List<Map<String, Object>> parseAuditResourceByActionToList(String action,
 748                         Map<AuditingFieldsKeysEnum, String> body) throws Exception {
 749
 750                 List<Map<String, Object>> auditList = new ArrayList<Map<String, Object>>();
 751
 752                 // String auditingMessage = null;
 753
 754                 Map auditingMessage = null;
 755
 756                 if (body == null || body.isEmpty()) {
 757                         auditingMessage = retrieveAuditMessagesByPattern(action, null, false);
 758                         // String pattern = "/_search?q=ACTION:\"" + action + "\"";
 759                         // auditingMessage = retrieveAuditMessagesByPattern(action);
 760                         // auditingMessage = retrieveAuditMessagesByPattern(pattern);
 761                 } else {
 762                         auditingMessage = retrieveAuditMessagesByPattern(action, body, false);
 763                         // auditingMessage = retrieveAuditMessagesUsingBody(body);
 764                 }
 765
 766                 return ResponseParser.getAuditFromMessage(auditingMessage);
 767
 768         }
 769
 770         public JSONObject buildElasticQueryStringObject(String defaultField, String queryValue) throws JSONException {
 771
 772                 JSONObject query_string = new JSONObject();
 773                 JSONObject jSONObject = new JSONObject();
 774                 jSONObject.put("default_field", defaultField);
 775                 jSONObject.put("query", queryValue);
 776
 777                 query_string.put("query_string", jSONObject);
 778
 779                 return query_string;
 780         }
 781
 782         public static JSONObject buildElasticQueryBody(List<JSONObject> listObjects) throws JSONException {
 783
 784                 JSONObject query = new JSONObject();
 785                 JSONObject bool = new JSONObject();
 786                 JSONObject must = new JSONObject();
 787                 JSONArray mustA = new JSONArray();
 788
 789                 for (int i = 0; i < listObjects.size(); i++) {
 790                         JSONObject match = new JSONObject();
 791                         match.put("match", listObjects.get(i));
 792                         mustA.put(match);
 793
 794                 }
 795
 796                 must.put("must", mustA);
 797                 bool.put("bool", must);
 798                 query.put("query", bool);
 799
 800                 return query;
 801         }
 802
 803         public static String retrieveAuditMessagesUsingBody(String query_string) throws IOException {
 804
 805                 Config config = Utils.getConfig();
 806                 HttpRequest getAuditingMessage = new HttpRequest();
 807                 Map<String, String> headersMap = new HashMap<String, String>();
 808                 String body = query_string;
 809
 810                 String url = String.format(Urls.GET_SEARCH_DATA_FROM_ES, config.getEsHost(), config.getEsPort(), "_search");
 811                 RestResponse restResponse = getAuditingMessage.httpSendPost(url, body, headersMap);
 812
 813                 return restResponse.getResponse();
 814         }
 815
 816         public static Map<String, String> retrieveAuditMessagesByPattern(String action, Map<AuditingFieldsKeysEnum, String> body, Boolean retryFlag)
 817                         throws IOException {
 818
 819                 // get cassandra table name by action
 820                 String esType = AuditingActionEnum.getActionByName(action).getAuditingEsType();
 821                 Map<String, String> resultsMap = new HashMap<String, String>();
 822
 823                 List<Pair<AuditingFieldsKeysEnum, String>> myFields = new ArrayList<Pair<AuditingFieldsKeysEnum, String>>();
 824                 Pair<AuditingFieldsKeysEnum, String> myPair = new Pair<AuditingFieldsKeysEnum, String>(
 825                                 AuditingFieldsKeysEnum.AUDIT_ACTION, action);
 826                 myFields.add(0, myPair);
 827                 if (body != null && !body.isEmpty()) {
 828                         for (Map.Entry<AuditingFieldsKeysEnum, String> mapElement : body.entrySet()) {
 829                                 myFields.add(new Pair<AuditingFieldsKeysEnum, String>(mapElement.getKey(), mapElement.getValue()));
 830                         }
 831                 }
 832
 833                 List<Row> fetchFromTable = CassandraUtils.fetchFromTable(auditKeySpaceName, esType, myFields);
 834                 if(retryFlag){
 835                         if(fetchFromTable.size() == 0){
 836                                 return resultsMap;
 837                         }
 838                 }
 839 //              assertTrue("expected on fetching from data base one record only, actual: " + fetchFromTable.size(), fetchFromTable.size() == 1);
 840
 841
 842
 843
 844                 Row row =null;
 845
 846                 if (fetchFromTable.size() > 1){
 847                         List<Row> fetchFromTable2 = fetchFromTable;
 848                         fetchFromTable2.sort((p1, p2) -> p1.getTimestamp(1).compareTo(p2.getTimestamp(1)));
 849                         row = fetchFromTable2.get(fetchFromTable2.size() - 1);
 850                 }
 851                 else {row = fetchFromTable.get(0);}
 852
 853                 ColumnDefinitions columnDefinitions = row.getColumnDefinitions();
 854
 855                 for (int i = 0; i < columnDefinitions.size(); i++) {
 856                         resultsMap.put(columnDefinitions.getName(i), row.getObject(columnDefinitions.getName(i)) == null ? "null"
 857                                         : row.getObject(columnDefinitions.getName(i)).toString());
 858                 }
 859
 860                 return resultsMap;
 861         }
 862
 863         // public static Map retrieveAuditMessagesByPattern(String pattern) throws
 864         // IOException {
 865         //
 866         //// Config config = Utils.getConfig();
 867         //// HttpRequest getAuditingMessage = new HttpRequest();
 868         //// String url = String.format(Urls.GET_SEARCH_DATA_FROM_ES,
 869         // config.getEsHost(), config.getEsPort(), pattern);
 870         //// RestResponse restResponse = getAuditingMessage.httpSendGet(url, null);
 871         //
 872         //// get cassandra table name by action
 873         // String esType =
 874         // AuditingActionEnum.getActionByName(pattern).getAuditingEsType();
 875         //// AuditingActionEnum actionByName =
 876         // AuditingActionEnum.getActionByName(pattern);
 877         //
 878         //// Map<AuditingFieldsKeysEnum, String> myFields= new
 879         // HashMap<AuditingFieldsKeysEnum, String>();
 880         //// myFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION , pattern);
 881         //
 882         // List<Pair<AuditingFieldsKeysEnum, String>> myFields = new
 883         // ArrayList<Pair<AuditingFieldsKeysEnum, String>>();
 884         // Pair<AuditingFieldsKeysEnum, String> myPair = new
 885         // Pair<AuditingFieldsKeysEnum, String>(AuditingFieldsKeysEnum.AUDIT_ACTION
 886         // , pattern);
 887         // myFields.add(0, myPair);
 888         //
 889         //
 890         // List<Row> fetchFromTable = CassandraUtils.fetchFromTable("sdcaudit",
 891         // esType, myFields);
 892         // Row row = fetchFromTable.get(0);
 893         //
 894         //
 895         // ColumnDefinitions columnDefinitions = row.getColumnDefinitions();
 896         //// String string = row.getString(columnDefinitions.getName(1));
 897         //
 898         //// String metaData = row.getColumnDefinitions().toString();
 899         //// metaData =metaData.replaceAll("\\((.*?)\\)|\\[|\\]|Columns", "");
 900         //// List<String> metaDataList = new
 901         // ArrayList<String>(Arrays.asList(metaData.split(", ")));
 902         //
 903         //
 904         //
 905         // Map<String, String> resultsMap = new HashMap<String, String>();
 906         //
 907         //
 908         // for (int i=0 ; i < columnDefinitions.size() ; i++){
 909         // resultsMap.put(columnDefinitions.getName(i) ,
 910         // row.getObject(columnDefinitions.getName(i)) == null ? "null" :
 911         // row.getObject(columnDefinitions.getName(i)).toString());
 912         // }
 913         //// for (String string : metaDataList) {
 914         //// resultsMap.put(string , row.getString(string));
 915         //// }
 916         ////
 917         //
 918         //// String dataString = fetchFromTable.toString();
 919         //// dataString = dataString.replaceAll("\\[|\\]|Row", "");
 920         //// List<String> dataArray = new
 921         // ArrayList<String>(Arrays.asList(dataString.split(", ")));
 922         ////
 923         ////
 924         //// Map<String, String> resultsMap = new HashMap<String, String>();
 925         //// for (int i=0 ; i<metaDataList.size() ; i++) {
 926         //// resultsMap.put(metaDataList.get(i), dataArray.get(i));
 927         //// }
 928         ////
 929         //// return restResponse.getResponse();
 930         // return resultsMap;
 931         // }
 932
 933         public static void categoryAuditSuccess(String action, CategoryDefinition categoryDefinition, User user, int status,
 934                         String resourceType) throws Exception {
 935                 categoryAuditSuccessInternal(action, categoryDefinition, null, null, user, status, resourceType);
 936         }
 937
 938         public static void categoryAuditFailure(String action, CategoryDefinition categoryDataDefinition, User user,
 939                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 940                 categoryAuditFailureInternal(action, categoryDataDefinition, null, null, user, errorMessage, status,
 941                                 resourceType, variables);
 942         }
 943
 944         public static void subCategoryAuditSuccess(String action, CategoryDefinition categoryDefinition,
 945                         SubCategoryDefinition subCategoryDefinition, User user, int status, String resourceType) throws Exception {
 946                 categoryAuditSuccessInternal(action, categoryDefinition, subCategoryDefinition, null, user, status,
 947                                 resourceType);
 948         }
 949
 950         public static void groupingAuditSuccess(String action, CategoryDefinition categoryDefinition,
 951                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user, int status,
 952                         String resourceType) throws Exception {
 953                 categoryAuditSuccessInternal(action, categoryDefinition, subCategoryDefinition, groupingDefinition, user,
 954                                 status, resourceType);
 955         }
 956
 957         public static void subCategoryAuditFailure(String action, CategoryDefinition categoryDataDefinition,
 958                         SubCategoryDefinition subCategoryDefinition, User user, ActionStatus errorMessage, int status,
 959                         String resourceType, Object... variables) throws Exception {
 960                 categoryAuditFailureInternal(action, categoryDataDefinition, subCategoryDefinition, null, user, errorMessage,
 961                                 status, resourceType, variables);
 962         }
 963
 964         // NEW Benny
 965         public static void groupingAuditFailure(String action, CategoryDefinition categoryDefinition,
 966                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user,
 967                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 968                 groupingAuditFailureInternal(action, categoryDefinition, subCategoryDefinition, groupingDefinition, user,
 969                                 errorMessage, status, resourceType, variables);
 970         }
 971
 972         private static void groupingAuditFailureInternal(String action, CategoryDefinition categoryDataDefinition,
 973                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user,
 974                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
 975                 // validate audit
 976                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
 977                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
 978                 expectedCatrgoryAuditJavaObject.setAction(action);
 979                 expectedCatrgoryAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
 980                 expectedCatrgoryAuditJavaObject.setCategoryName(categoryDataDefinition.getName());
 981                 String subCategoryName = (subCategoryDefinition != null ? subCategoryDefinition.getName()
 982                                 : Constants.EMPTY_STRING);
 983                 expectedCatrgoryAuditJavaObject.setSubCategoryName(subCategoryName);
 984                 String groupingName = (groupingDefinition != null ? groupingDefinition.getName() : Constants.EMPTY_STRING);
 985                 expectedCatrgoryAuditJavaObject.setGroupingName(groupingName);
 986                 expectedCatrgoryAuditJavaObject.setResourceType(resourceType);
 987                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(status));
 988                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
 989                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, action);
 990         }
 991
 992         ///
 993         private static void categoryAuditSuccessInternal(String action, CategoryDefinition categoryDefinition,
 994                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user, int status,
 995                         String resourceType) throws Exception {
 996                 // resourceType = Service/Resource/Product
 997                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
 998                 expectedCatrgoryAuditJavaObject.setAction(action);
 999                 expectedCatrgoryAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
1000                 expectedCatrgoryAuditJavaObject.setCategoryName(categoryDefinition.getName());
1001                 String subCategoryName = (subCategoryDefinition != null ? subCategoryDefinition.getName()
1002                                 : Constants.EMPTY_STRING);
1003                 expectedCatrgoryAuditJavaObject.setSubCategoryName(subCategoryName);
1004                 String groupingName = (groupingDefinition != null ? groupingDefinition.getName() : Constants.EMPTY_STRING);
1005                 expectedCatrgoryAuditJavaObject.setGroupingName(groupingName);
1006                 expectedCatrgoryAuditJavaObject.setResourceType(resourceType);
1007                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(status));
1008                 expectedCatrgoryAuditJavaObject.setDesc("OK");
1009                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, action);
1010         }
1011
1012         ///////////////////////////
1013         ///// BENNNNNNNNY
1014         public enum UserAuditJsonKeysEnum {
1015                 ACTION("ACTION"), MODIFIER("MODIFIER"), STATUS("STATUS"), DESC("DESCRIPTION"), USER_AFTER(
1016                                 "USER_AFTER"), USER_BEFORE("USER_BEFORE");
1017                 private String auditJsonKeyName;
1018
1019                 private UserAuditJsonKeysEnum(String auditJsonKeyName) {
1020                         this.auditJsonKeyName = auditJsonKeyName;
1021                 }
1022
1023                 public String getAuditJsonKeyName() {
1024                         return auditJsonKeyName.toLowerCase();
1025                 }
1026         }
1027
1028         public static void validateAddUserAudit(ExpectedUserCRUDAudit expectedAddUserAuditJavaObject, String action)
1029                         throws Exception {
1030
1031                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedAddUserAuditJavaObject.getAction(), 1);
1032                 Map<String, Object> map = actionToList.get(0);
1033                 validateField(map, UserAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
1034                 validateField(map, UserAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
1035                                 expectedAddUserAuditJavaObject.getModifier());
1036                 validateField(map, UserAuditJsonKeysEnum.USER_AFTER.getAuditJsonKeyName(),
1037                                 expectedAddUserAuditJavaObject.getUserAfter());
1038                 validateField(map, UserAuditJsonKeysEnum.USER_BEFORE.getAuditJsonKeyName(),
1039                                 expectedAddUserAuditJavaObject.getUserBefore());
1040                 validateField(map, UserAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
1041                                 expectedAddUserAuditJavaObject.getStatus());
1042                 validateField(map, UserAuditJsonKeysEnum.DESC.getAuditJsonKeyName(), expectedAddUserAuditJavaObject.getDesc());
1043
1044         }
1045
1046         private static void categoryAuditFailureInternal(String action, CategoryDefinition categoryDataDefinition,
1047                         SubCategoryDefinition subCategoryDefinition, GroupingDefinition groupingDefinition, User user,
1048                         ActionStatus errorMessage, int status, String resourceType, Object... variables) throws Exception {
1049                 // validate audit
1050                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorMessage.name());
1051                 ExpectedCategoryAudit expectedCatrgoryAuditJavaObject = new ExpectedCategoryAudit();
1052                 expectedCatrgoryAuditJavaObject.setAction(action);
1053                 expectedCatrgoryAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
1054                 expectedCatrgoryAuditJavaObject.setCategoryName(categoryDataDefinition.getName());
1055                 String subCategoryName = (subCategoryDefinition != null ? subCategoryDefinition.getName()
1056                                 : Constants.EMPTY_STRING);
1057                 expectedCatrgoryAuditJavaObject.setSubCategoryName(subCategoryName);
1058                 String groupingName = (groupingDefinition != null ? groupingDefinition.getName() : Constants.EMPTY_STRING);
1059                 expectedCatrgoryAuditJavaObject.setGroupingName(groupingName);
1060                 expectedCatrgoryAuditJavaObject.setResourceType(resourceType);
1061                 expectedCatrgoryAuditJavaObject.setStatus(String.valueOf(status));
1062                 expectedCatrgoryAuditJavaObject.setDesc(errorInfo.getAuditDesc(variables));
1063                 AuditValidationUtils.validateCategoryAudit(expectedCatrgoryAuditJavaObject, action);
1064         }
1065
1066         public static void validateGetCategoryHirarchy(ExpectedCategoryAudit expectedCatrgoryAuditJavaObject, String action)
1067                         throws Exception {
1068
1069                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedCatrgoryAuditJavaObject.getAction(), 1);
1070                 Map<String, Object> map = actionToList.get(0);
1071
1072                 expectedCatrgoryAuditJavaObject.setModifier(getModifierString(expectedCatrgoryAuditJavaObject.getModifierName(),
1073                                 expectedCatrgoryAuditJavaObject.getModifierUid()));
1074                 validateField(map, CategoryAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
1075                 validateField(map, CategoryAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
1076                                 expectedCatrgoryAuditJavaObject.getModifier());
1077                 validateField(map, CategoryAuditJsonKeysEnum.DETAILS.getAuditJsonKeyName(),
1078                                 expectedCatrgoryAuditJavaObject.getDetails());
1079                 validateField(map, CategoryAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
1080                                 expectedCatrgoryAuditJavaObject.getStatus());
1081                 validateField(map, CategoryAuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(),
1082                                 expectedCatrgoryAuditJavaObject.getDesc());
1083
1084         }
1085
1086         public static void validateCategoryAudit(ExpectedCategoryAudit expectedCatrgoryAuditJavaObject, String action)
1087                         throws Exception {
1088
1089                 List<Map<String, Object>> actionToList = getAuditListByAction(expectedCatrgoryAuditJavaObject.getAction(), 1);
1090                 Map<String, Object> map = actionToList.get(0);
1091                 validateField(map, CategoryAuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
1092                 validateField(map, CategoryAuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(),
1093                                 expectedCatrgoryAuditJavaObject.getModifier());
1094                 validateField(map, CategoryAuditJsonKeysEnum.CATEGORY_NAME.getAuditJsonKeyName(),
1095                                 expectedCatrgoryAuditJavaObject.getCategoryName());
1096                 validateField(map, CategoryAuditJsonKeysEnum.SUB_CATEGORY_NAME.getAuditJsonKeyName(),
1097                                 expectedCatrgoryAuditJavaObject.getSubCategoryName());
1098                 validateField(map, CategoryAuditJsonKeysEnum.GROUPING_NAME.getAuditJsonKeyName(),
1099                                 expectedCatrgoryAuditJavaObject.getGroupingName());
1100                 validateField(map, CategoryAuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
1101                                 expectedCatrgoryAuditJavaObject.getResourceType());
1102                 validateField(map, CategoryAuditJsonKeysEnum.STATUS.getAuditJsonKeyName(),
1103                                 expectedCatrgoryAuditJavaObject.getStatus());
1104                 validateField(map, CategoryAuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(),
1105                                 expectedCatrgoryAuditJavaObject.getDesc());
1106         }
1107
1108         public static void GetCategoryHierarchyAuditSuccess(String action, String componentType, User user, int status)
1109                         throws Exception {
1110                 ExpectedGetUserListAudit expectedGetListOfUsersAuditJavaObject = new ExpectedGetUserListAudit();
1111                 expectedGetListOfUsersAuditJavaObject.setAction(action);
1112                 expectedGetListOfUsersAuditJavaObject.setStatus(String.valueOf(status));
1113                 expectedGetListOfUsersAuditJavaObject.setDesc("OK");
1114                 expectedGetListOfUsersAuditJavaObject.setModifier(user.getFullName() + "(" + user.getUserId() + ")");
1115                 expectedGetListOfUsersAuditJavaObject.setDetails(componentType.toLowerCase());
1116                 validateAuditGetListOfUsersByRoles(expectedGetListOfUsersAuditJavaObject, action);
1117         }
1118
1119         public static String buildArtifactDataAudit(ArtifactDefinition artifactDefinition) {
1120                 StringBuilder sb = new StringBuilder();
1121                 if (artifactDefinition.getTimeout() == null) {
1122                         artifactDefinition.setTimeout(0);
1123                 }
1124                 if (artifactDefinition != null) {
1125                         sb.append(artifactDefinition.getArtifactGroupType() == null ? null
1126                                         : artifactDefinition.getArtifactGroupType().getType()).append(",").append("'")
1127                                         .append(artifactDefinition.getArtifactLabel()).append("'").append(",")
1128                                         .append(artifactDefinition.getArtifactType()).append(",")
1129                                         .append(artifactDefinition.getArtifactName()).append(",").append(artifactDefinition.getTimeout())
1130                                         .append(",").append(artifactDefinition.getEsId());
1131                         sb.append(",");
1132                         if (artifactDefinition.getArtifactVersion() != null) {
1133                                 sb.append(artifactDefinition.getArtifactVersion());
1134                         } else {
1135                                 sb.append(" ");
1136                         }
1137                         sb.append(",");
1138                         if (artifactDefinition.getArtifactUUID() != null) {
1139                                 sb.append(artifactDefinition.getArtifactUUID());
1140                         } else {
1141                                 sb.append(" ");
1142                         }
1143                 }
1144
1145                 return sb.toString();
1146         }
1147
1148         public static ExpectedResourceAuditJavaObject expectedMissingInformationAuditObject(String Action,
1149                         String resourceUid, ComponentType resourceType) throws FileNotFoundException {
1150                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1151                 expectedAudit.setAction(Action);
1152                 expectedAudit.setResourceName(resourceUid);
1153                 expectedAudit.setResourceType(resourceType.getValue());
1154                 expectedAudit.setPrevVersion("");
1155                 expectedAudit.setCurrVersion("");
1156                 expectedAudit.setModifierName("");
1157                 expectedAudit.setModifierUid("");
1158                 expectedAudit.setPrevState("");
1159                 expectedAudit.setCurrState("");
1160                 expectedAudit.setPrevArtifactUuid("");
1161                 expectedAudit.setCurrArtifactUuid("");
1162                 expectedAudit.setArtifactData("");
1163                 expectedAudit.setStatus("403");
1164                 expectedAudit.setDesc(buildAuditDescription(
1165                                 new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.MISSING_INFORMATION.name()),
1166                                 new ArrayList<String>()));
1167                 return expectedAudit;
1168         }
1169
1170         public static ExpectedResourceAuditJavaObject expectedComponentNotFoundAuditObject(String Action,
1171                         String resourceUid, ComponentType resourceType, String artifactUid, User user,
1172                         ArrayList<String> notFoundComponent) throws FileNotFoundException {
1173                 String desc = null;
1174
1175                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1176                 expectedAudit.setAction(Action);
1177                 expectedAudit.setResourceName(resourceUid);
1178                 expectedAudit.setResourceType(resourceType.getValue());
1179                 expectedAudit.setPrevVersion("");
1180                 expectedAudit.setCurrVersion("");
1181                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
1182                 expectedAudit.setModifierUid(user.getUserId());
1183                 expectedAudit.setPrevState("");
1184                 expectedAudit.setCurrState("");
1185                 expectedAudit.setPrevArtifactUuid("");
1186                 expectedAudit.setCurrArtifactUuid(artifactUid);
1187                 expectedAudit.setArtifactData("");
1188                 expectedAudit.setStatus("404");
1189
1190                 if (resourceType.getValue() == ComponentType.SERVICE.getValue()) {
1191                         desc = buildAuditDescription(
1192                                         new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.SERVICE_NOT_FOUND.name()),
1193                                         notFoundComponent);
1194                 } else if (resourceType.getValue() == ComponentType.RESOURCE.getValue())
1195                         desc = buildAuditDescription(
1196                                         new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.RESOURCE_NOT_FOUND.name()),
1197                                         notFoundComponent);
1198
1199                 expectedAudit.setDesc(desc);
1200                 return expectedAudit;
1201         }
1202
1203         public static ExpectedResourceAuditJavaObject expectedArtifactNotFoundAuditObject(String Action, String resourceUid,
1204                         ComponentType resourceType, String artifactUid, User user, String currState, String currVersion)
1205                         throws FileNotFoundException {
1206                 String desc = null;
1207
1208                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1209                 expectedAudit.setAction(Action);
1210                 expectedAudit.setResourceName(resourceUid);
1211                 expectedAudit.setResourceType(resourceType.getValue());
1212                 expectedAudit.setPrevVersion("");
1213                 expectedAudit.setCurrVersion(currVersion);
1214                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
1215                 expectedAudit.setModifierUid(user.getUserId());
1216                 expectedAudit.setPrevState("");
1217                 expectedAudit.setCurrState(currState);
1218                 expectedAudit.setPrevArtifactUuid("");
1219                 expectedAudit.setCurrArtifactUuid(artifactUid);
1220                 expectedAudit.setArtifactData("");
1221                 expectedAudit.setStatus("404");
1222
1223                 desc = buildAuditDescription(
1224                                 new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name()),
1225                                 Arrays.asList(""));
1226
1227                 expectedAudit.setDesc(desc);
1228                 return expectedAudit;
1229         }
1230
1231         public static ExpectedResourceAuditJavaObject expectedArtifactNotFoundAuditObject(String Action,
1232                         String resourceName, ComponentType resourceType, String artifactUid, LifecycleStateEnum lifecycle,
1233                         User user, String currVersion) throws FileNotFoundException {
1234                 String desc = null;
1235
1236                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1237                 expectedAudit.setAction(Action);
1238                 expectedAudit.setResourceName(resourceName);
1239                 expectedAudit.setResourceType(resourceType.getValue());
1240                 expectedAudit.setPrevVersion("");
1241                 expectedAudit.setCurrVersion(currVersion);
1242                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
1243                 expectedAudit.setModifierUid(user.getUserId());
1244                 expectedAudit.setPrevState("");
1245                 expectedAudit.setCurrState(lifecycle.name());
1246                 expectedAudit.setPrevArtifactUuid("");
1247                 expectedAudit.setCurrArtifactUuid(artifactUid);
1248                 expectedAudit.setArtifactData("");
1249                 expectedAudit.setStatus("404");
1250
1251                 desc = buildAuditDescription(
1252                                 new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.ARTIFACT_NOT_FOUND.name()),
1253                                 new ArrayList<String>());
1254
1255                 expectedAudit.setDesc(desc);
1256                 return expectedAudit;
1257         }
1258
1259         public static ExpectedResourceAuditJavaObject expectedRestrictedOperationAuditObject(String Action,
1260                         String resourceNameOrUid, ComponentType resourceType, String artifactUid, User user, String currVersion,
1261                         String currState) throws FileNotFoundException {
1262                 String desc = null;
1263
1264                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1265                 expectedAudit.setAction(Action);
1266                 expectedAudit.setResourceName(resourceNameOrUid);
1267                 expectedAudit.setResourceType(resourceType.getValue());
1268                 expectedAudit.setPrevVersion("");
1269                 expectedAudit.setCurrVersion(currVersion);
1270                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
1271                 expectedAudit.setModifierUid(user.getUserId());
1272                 expectedAudit.setPrevState("");
1273                 expectedAudit.setCurrState(currState);
1274                 expectedAudit.setPrevArtifactUuid("");
1275                 expectedAudit.setCurrArtifactUuid(artifactUid);
1276                 expectedAudit.setArtifactData("");
1277                 expectedAudit.setStatus("409");
1278
1279                 desc = buildAuditDescription(
1280                                 new ErrorValidationUtils().parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name()),
1281                                 new ArrayList<String>());
1282
1283                 expectedAudit.setDesc(desc);
1284                 return expectedAudit;
1285         }
1286
1287         public static ExpectedResourceAuditJavaObject expectedInvalidContentAuditObject(String Action, String resourceName,
1288                         ComponentType resourceType, String artifactUid, User user, String currVersion, String currState,
1289                         ArrayList<String> invalidContentList) throws FileNotFoundException {
1290                 return expectedInvalidContentAuditObject(ActionStatus.INVALID_CONTENT, Action, resourceName, resourceType,
1291                                 artifactUid, user, currVersion, currState, invalidContentList);
1292         }
1293
1294         public static ExpectedResourceAuditJavaObject expectedInvalidContentAuditObject(ActionStatus actionStatus,
1295                         String Action, String resourceName, ComponentType resourceType, String artifactUid, User user,
1296                         String currVersion, String currState, ArrayList<String> invalidContentList) throws FileNotFoundException {
1297                 String desc = null;
1298
1299                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1300                 expectedAudit.setAction(Action);
1301                 expectedAudit.setResourceName(resourceName);
1302                 expectedAudit.setResourceType(resourceType.getValue());
1303                 expectedAudit.setPrevVersion("");
1304                 expectedAudit.setCurrVersion(currVersion);
1305                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
1306                 expectedAudit.setModifierUid(user.getUserId());
1307                 expectedAudit.setPrevState("");
1308                 expectedAudit.setCurrState(currState);
1309                 expectedAudit.setPrevArtifactUuid("");
1310                 expectedAudit.setCurrArtifactUuid(artifactUid);
1311                 expectedAudit.setArtifactData("");
1312                 expectedAudit.setStatus("400");
1313
1314                 desc = buildAuditDescription(new ErrorValidationUtils().parseErrorConfigYaml(actionStatus.name()),
1315                                 invalidContentList);
1316
1317                 expectedAudit.setDesc(desc);
1318                 return expectedAudit;
1319         }
1320
1321         public static ExpectedResourceAuditJavaObject expectedSuccessAuditObject(String Action, String resourceName,
1322                         ComponentType resourceType, ArtifactReqDetails artifactReq, User user, String currVersion, String currState,
1323                         String prevArtifactUuid) throws FileNotFoundException {
1324                 ExpectedResourceAuditJavaObject expectedAudit = new ExpectedResourceAuditJavaObject();
1325                 expectedAudit.setAction(Action);
1326                 expectedAudit.setResourceName(resourceName);
1327                 expectedAudit.setResourceType(resourceType.getValue());
1328                 expectedAudit.setPrevVersion("");
1329                 expectedAudit.setCurrVersion(currVersion);
1330                 expectedAudit.setModifierName(user.getFirstName() + " " + user.getLastName());
1331                 expectedAudit.setModifierUid(user.getUserId());
1332                 expectedAudit.setPrevState("");
1333                 expectedAudit.setCurrState(currState);
1334                 expectedAudit.setPrevArtifactUuid(prevArtifactUuid);
1335                 expectedAudit.setCurrArtifactUuid(artifactReq.getUniqueId());
1336                 expectedAudit
1337                                 .setArtifactData(buildArtifactDataAudit(ArtifactUtils.convertArtifactReqToDefinition(artifactReq)));
1338                 expectedAudit.setStatus("200");
1339                 expectedAudit.setDesc("OK");
1340                 return expectedAudit;
1341         }
1342
1343         public static JSONObject filterAuditByUuid(String action, String uuid) throws Exception {
1344                 Map<String, String> actionMap = new HashMap<String, String>();
1345                 actionMap.put("ACTION", action);
1346                 JSONObject actionJsonObject = new JSONObject(actionMap);
1347                 Map<String, String> uuidMap = new HashMap<String, String>();
1348                 uuidMap.put("SERVICE_INSTANCE_ID", uuid);
1349                 JSONObject uuidJsonObject = new JSONObject(uuidMap);
1350
1351                 List<JSONObject> filters = new ArrayList<JSONObject>(Arrays.asList(actionJsonObject, uuidJsonObject));
1352                 JSONObject body = buildElasticQueryBody(filters);
1353                 return body;
1354         }
1355
1356         public static void validateAudit(ExpectedResourceAuditJavaObject resourceAuditJavaObject, String action)
1357                         throws Exception {
1358                 List<Map<String, Object>> actionToList = getAuditListByAction(resourceAuditJavaObject.getAction(), 1);
1359                 Map<String, Object> map2 = actionToList.get(0);
1360                 validateField(map2, AuditJsonKeysEnum.ACTION.getAuditJsonKeyName(), action);
1361                 validateField(map2, AuditJsonKeysEnum.RESOURCE_NAME.getAuditJsonKeyName(),
1362                                 resourceAuditJavaObject.getResourceName());
1363                 validateField(map2, AuditJsonKeysEnum.RESOURCE_TYPE.getAuditJsonKeyName(),
1364                                 resourceAuditJavaObject.getResourceType());
1365                 validateField(map2, AuditJsonKeysEnum.PREV_VERSION.getAuditJsonKeyName(),
1366                                 resourceAuditJavaObject.getPrevVersion());
1367                 validateField(map2, AuditJsonKeysEnum.CURR_VERSION.getAuditJsonKeyName(),
1368                                 resourceAuditJavaObject.getCurrVersion());
1369                 validateField(map2, AuditJsonKeysEnum.MODIFIER.getAuditJsonKeyName(), resourceAuditJavaObject.getMODIFIER());
1370                 validateField(map2, AuditJsonKeysEnum.PREV_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getPrevState());
1371                 validateField(map2, AuditJsonKeysEnum.CURR_STATE.getAuditJsonKeyName(), resourceAuditJavaObject.getCurrState());
1372                 validateField(map2, AuditJsonKeysEnum.STATUS.getAuditJsonKeyName(), resourceAuditJavaObject.getStatus());
1373                 validateField(map2, AuditJsonKeysEnum.DESCRIPTION.getAuditJsonKeyName(), resourceAuditJavaObject.getDesc());
1374                 validateField(map2, AuditJsonKeysEnum.COMMENT.getAuditJsonKeyName(), resourceAuditJavaObject.getComment());
1375         }
1376
1377         ////// service audit validation/////////////////////
1378
1379         public static ExpectedResourceAuditJavaObject constructFieldsForAuditValidation(ServiceReqDetails serviceReqDetails,
1380                         String serviceVersion, User sdncUserDetails) {
1381
1382                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
1383
1384                 expectedResourceAuditJavaObject.setAction("Create");
1385                 expectedResourceAuditJavaObject.setModifierUid(sdncUserDetails.getUserId());
1386                 String userFirstLastName = sdncUserDetails.getFirstName() + " " + sdncUserDetails.getLastName();
1387                 expectedResourceAuditJavaObject.setModifierName(userFirstLastName);
1388                 expectedResourceAuditJavaObject.setStatus("200");
1389                 expectedResourceAuditJavaObject.setDesc("OK");
1390                 expectedResourceAuditJavaObject.setResourceName(serviceReqDetails.getName());
1391                 expectedResourceAuditJavaObject.setResourceType("Service");
1392                 expectedResourceAuditJavaObject.setPrevVersion(String.valueOf(Float.parseFloat(serviceVersion) - 0.1f));
1393                 expectedResourceAuditJavaObject.setCurrVersion(serviceVersion);
1394                 expectedResourceAuditJavaObject.setPrevState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1395                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1396                 expectedResourceAuditJavaObject.setComment(null);
1397
1398                 return expectedResourceAuditJavaObject;
1399
1400         }
1401
1402         public static ExpectedResourceAuditJavaObject constructFieldsForAuditValidation(ServiceReqDetails serviceReqDetails,
1403                         String serviceVersion, User sdncUserDetails, ActionStatus errorStatus, List<String> variables)
1404                         throws FileNotFoundException {
1405
1406                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = constructFieldsForAuditValidation(
1407                                 serviceReqDetails, serviceVersion, sdncUserDetails);
1408                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorStatus.name());
1409
1410                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1411                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
1412                 expectedResourceAuditJavaObject.setDesc(auditDesc);
1413
1414                 return expectedResourceAuditJavaObject;
1415
1416         }
1417
1418 }