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