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