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