test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/validation/ResourceValidationUtils.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.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.Iterator;
  29 import java.util.LinkedHashSet;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33
  34 import org.openecomp.sdc.be.model.ArtifactDefinition;
  35 import org.openecomp.sdc.be.model.InterfaceDefinition;
  36 import org.openecomp.sdc.be.model.Operation;
  37 import org.openecomp.sdc.be.model.Resource;
  38 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  39 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  40 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
  41 import org.openecomp.sdc.ci.tests.datatypes.enums.RespJsonKeysEnum;
  42 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  43 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  44
  45 import com.google.gson.Gson;
  46
  47 public class ResourceValidationUtils {
  48
  49         public static void validateResourceReqVsResp(ResourceReqDetails resourceDetails,
  50                         ResourceRespJavaObject resourceRespJavaObject) {
  51
  52                 String expected;
  53
  54                 expected = resourceDetails.getDescription();
  55                 assertEquals("resource description - ", expected, resourceRespJavaObject.getDescription());
  56
  57                 expected = resourceDetails.getVendorName();
  58                 assertEquals("resource vendorName - ", expected, resourceRespJavaObject.getVendorName());
  59
  60                 expected = resourceDetails.getVendorRelease();
  61                 assertEquals("resource vendorReleaseName - ", expected, resourceRespJavaObject.getVendorRelease());
  62
  63                 expected = resourceDetails.getContactId();
  64                 assertEquals("resource contactId - ", expected, resourceRespJavaObject.getContactId());
  65
  66         }
  67
  68         public static void validateResourceReqVsResp(ResourceReqDetails resourceDetails, Resource resourceRespJavaObject) {
  69
  70                 String expected;
  71
  72                 expected = resourceDetails.getDescription();
  73                 assertEquals("resource description - ", expected, resourceRespJavaObject.getDescription());
  74
  75                 expected = resourceDetails.getVendorName();
  76                 assertEquals("resource vendorName - ", expected, resourceRespJavaObject.getVendorName());
  77
  78                 expected = resourceDetails.getVendorRelease();
  79                 assertEquals("resource vendorReleaseName - ", expected, resourceRespJavaObject.getVendorRelease());
  80
  81                 expected = resourceDetails.getContactId();
  82                 assertEquals("resource contactId - ", expected, resourceRespJavaObject.getContactId());
  83
  84                 // Validating deduplication of tags
  85                 List<String> expectedTags = resourceDetails.getTags();
  86                 if (expectedTags != null) {
  87                         Set<String> hs = new LinkedHashSet<>(expectedTags);
  88                         expectedTags.clear();
  89                         expectedTags.addAll(hs);
  90                         List<String> receivedTags = resourceRespJavaObject.getTags();
  91                         assertEquals("resource tags - ", expectedTags, receivedTags);
  92                 }
  93
  94         }
  95
  96         public static void validateModelObjects(Resource expected, Resource actual) throws Exception {
  97
  98                 compareElements(expected.getUniqueId(), actual.getUniqueId());
  99                 compareElements(expected.getName(), actual.getName());
 100                 compareElements(expected.getVersion(), actual.getVersion());
 101                 compareElements(expected.getCreatorUserId(), actual.getCreatorUserId());
 102                 compareElements(expected.getCreatorFullName(), actual.getCreatorFullName());
 103                 compareElements(expected.getLastUpdaterUserId(), actual.getLastUpdaterUserId());
 104                 compareElements(expected.getLastUpdaterFullName(), actual.getLastUpdaterFullName());
 105                 compareElements(expected.getCreatorFullName(), actual.getCreatorFullName());
 106                 compareElements(expected.getCreationDate(), actual.getCreationDate());
 107                 compareElements(expected.getLastUpdateDate(), actual.getLastUpdateDate());
 108                 compareElements(expected.getDescription(), actual.getDescription());
 109                 compareElements(expected.getIcon(), actual.getIcon());
 110                 compareElements(expected.getLastUpdateDate(), actual.getLastUpdateDate());
 111                 // TODO compare tags
 112                 compareElements(expected.getCategories(), actual.getCategories());
 113                 compareElements(expected.getLifecycleState(), actual.getLifecycleState());
 114                 compareElements(expected.getVendorName(), actual.getVendorName());
 115                 compareElements(expected.getVendorRelease(), actual.getVendorRelease());
 116                 compareElements(expected.getContactId(), actual.getContactId());
 117                 compareElements(expected.getUUID(), actual.getUUID());
 118                 compareElements(expected.getVersion(), actual.getVersion());
 119
 120         }
 121
 122         public static void validateResp(RestResponse restResponse, ResourceRespJavaObject resourceRespJavaObject)
 123                         throws Exception {
 124
 125                 Gson gson = new Gson();
 126                 String response = restResponse.getResponse();
 127
 128                 validateResp(response, resourceRespJavaObject, gson);
 129
 130         }
 131
 132         public static void validateResp(String response, ResourceRespJavaObject resourceRespJavaObject, Gson gson) {
 133
 134                 Map<String, Object> map = new HashMap<String, Object>();
 135                 map = (Map<String, Object>) gson.fromJson(response, map.getClass());
 136
 137                 // De-duplicating the tags list for comparison
 138                 List<String> tags = resourceRespJavaObject.getTags();
 139                 if (tags != null) {
 140                         Set<String> hs = new LinkedHashSet<>(tags);
 141                         tags = new ArrayList<String>(hs);
 142                         resourceRespJavaObject.setTags(tags);
 143                         tags = new ArrayList<String>(hs);
 144                         resourceRespJavaObject.setTags(tags);
 145                 }
 146
 147                 validateField(map, RespJsonKeysEnum.RESOURCE_NAME.getRespJsonKeyName(), resourceRespJavaObject.getName());
 148                 validateField(map, RespJsonKeysEnum.RESOURCE_DESC.getRespJsonKeyName(),
 149                                 resourceRespJavaObject.getDescription());
 150                 // validateField(map, RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName(),
 151                 // resourceRespJavaObject.getCategories());
 152                 validateField(map, RespJsonKeysEnum.VENDOR_NAME.getRespJsonKeyName(), resourceRespJavaObject.getVendorName());
 153                 validateField(map, RespJsonKeysEnum.VENDOR_RELEASE.getRespJsonKeyName(),
 154                                 resourceRespJavaObject.getVendorRelease());
 155                 validateField(map, RespJsonKeysEnum.CONTACT_ID.getRespJsonKeyName(), resourceRespJavaObject.getContactId());
 156                 validateField(map, RespJsonKeysEnum.ICON.getRespJsonKeyName(), resourceRespJavaObject.getIcon());
 157                 validateField(map, RespJsonKeysEnum.IS_ABSTRACT.getRespJsonKeyName(),
 158                                 Boolean.valueOf(resourceRespJavaObject.getAbstractt()));
 159                 validateField(map, RespJsonKeysEnum.HIGHEST_VERSION.getRespJsonKeyName(),
 160                                 Boolean.valueOf(resourceRespJavaObject.getIsHighestVersion()));
 161                 validateField(map, RespJsonKeysEnum.UNIQUE_ID.getRespJsonKeyName(), resourceRespJavaObject.getUniqueId());
 162                 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceRespJavaObject.getVersion());
 163                 validateField(map, RespJsonKeysEnum.LIFE_CYCLE_STATE.getRespJsonKeyName(),
 164                                 resourceRespJavaObject.getLifecycleState());
 165                 validateField(map, RespJsonKeysEnum.TAGS.getRespJsonKeyName(), tags);
 166                 validateField(map, RespJsonKeysEnum.CREATOR_ATT_UID.getRespJsonKeyName(),
 167                                 resourceRespJavaObject.getCreatorUserId());
 168                 validateField(map, RespJsonKeysEnum.CREATOR_FULL_NAME.getRespJsonKeyName(),
 169                                 resourceRespJavaObject.getCreatorFullName());
 170                 validateField(map, RespJsonKeysEnum.LAST_UPDATER_ATT_UID.getRespJsonKeyName(),
 171                                 resourceRespJavaObject.getLastUpdaterUserId());
 172                 validateField(map, RespJsonKeysEnum.LAST_UPDATER_FULL_NAME.getRespJsonKeyName(),
 173                                 resourceRespJavaObject.getLastUpdaterFullName());
 174                 validateField(map, RespJsonKeysEnum.COST.getRespJsonKeyName(), resourceRespJavaObject.getCost());
 175                 validateField(map, RespJsonKeysEnum.LICENSE_TYPE.getRespJsonKeyName(), resourceRespJavaObject.getLicenseType());
 176                 validateField(map, RespJsonKeysEnum.RESOURCE_TYPE.getRespJsonKeyName(),
 177                                 resourceRespJavaObject.getResourceType().toString());
 178                 if (resourceRespJavaObject.getResourceType().equals("VF")) {
 179                         validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(), null);
 180                 } else {
 181                         validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(),
 182                                         resourceRespJavaObject.getDerivedFrom());
 183                 }
 184
 185                 validateCategories(resourceRespJavaObject, map);
 186
 187                 String uuid = ResponseParser.getValueFromJsonResponse(response, RespJsonKeysEnum.UUID.getRespJsonKeyName());
 188                 assertTrue("UUID is empty", uuid != null && !uuid.isEmpty());
 189         }
 190
 191         private static void validateCategories(ResourceRespJavaObject resourceRespJavaObject, Map<String, Object> map) {
 192                 assertTrue(RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName() + " is missing",
 193                                 map.containsKey(RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName()));
 194                 Object foundValue = map.get(RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName());
 195                 List<Map<String, Object>> foundList = (List<Map<String, Object>>) foundValue;
 196                 List<CategoryDefinition> excpectedList = resourceRespJavaObject.getCategories();
 197
 198                 assertTrue(foundList.size() == excpectedList.size());
 199                 for (int i = 0; i < foundList.size(); i++) {
 200                         CategoryDefinition expCat = excpectedList.get(i);
 201                         Map<String, Object> foun = foundList.get(i);
 202                         assertTrue("expected " + expCat.getName() + " not equal to actual " + foundValue,
 203                                         foun.get("name").equals(expCat.getName()));
 204                 }
 205         }
 206
 207         public static void validateField(Map<String, Object> map, String jsonField, Object expectedValue) {
 208                 if (expectedValue == null) {
 209                         assertTrue(jsonField + " is expected to be null", !map.containsKey(jsonField));
 210                 } else {
 211                         assertTrue(jsonField + " is missing", map.containsKey(jsonField));
 212                         Object foundValue = map.get(jsonField);
 213                         compareElements(expectedValue, foundValue);
 214                 }
 215         }
 216
 217         public static void compareElements(Object expectedValue, Object foundValue) {
 218                 if (expectedValue instanceof String) {
 219                         assertTrue(foundValue instanceof String);
 220                         assertTrue("expected " + expectedValue + " not equal to actual " + foundValue,
 221                                         foundValue.equals(expectedValue));
 222                 }
 223                 /*
 224                  * else if( expectedValue instanceof Number){ assertTrue(foundValue
 225                  * instanceof Number); assertTrue(foundValue == expectedValue); }
 226                  */
 227                 else if (expectedValue instanceof Boolean) {
 228                         assertTrue(foundValue instanceof Boolean);
 229                         assertTrue(foundValue == expectedValue);
 230                 } else if (expectedValue instanceof Map) {
 231                         assertTrue(foundValue instanceof Map);
 232                         Map<String, Object> foundMap = (Map<String, Object>) foundValue;
 233                         Map<String, Object> excpectedMap = (Map<String, Object>) expectedValue;
 234                         assertTrue(foundMap.size() == excpectedMap.size());
 235                         Iterator<String> foundkeyItr = foundMap.keySet().iterator();
 236                         while (foundkeyItr.hasNext()) {
 237                                 String foundKey = foundkeyItr.next();
 238                                 assertTrue(excpectedMap.containsKey(foundKey));
 239                                 compareElements(excpectedMap.get(foundKey), foundMap.get(foundKey));
 240                         }
 241
 242                 } else if (expectedValue instanceof List) {
 243                         assertTrue(foundValue instanceof List);
 244                         List<Object> foundList = (List<Object>) foundValue;
 245                         List<Object> excpectedList = (List<Object>) expectedValue;
 246                         assertTrue(foundList.size() == excpectedList.size());
 247                         for (int i = 0; i < foundList.size(); i++) {
 248                                 compareElements(excpectedList.get(i), foundList.get(i));
 249                         }
 250
 251                 } else {
 252                         assertTrue(foundValue.equals(expectedValue));
 253                 }
 254         }
 255
 256         public static boolean validateUuidAfterChangingStatus(String oldUuid, String newUuid) {
 257                 return oldUuid.equals(newUuid);
 258
 259         }
 260
 261         public static void validateRespArt(RestResponse restResponse, ResourceRespJavaObject resourceRespJavaObject,
 262                         String interfaze) throws Exception {
 263
 264                 Gson gson = new Gson();
 265                 String response = restResponse.getResponse();
 266
 267                 Map<String, Object> map = new HashMap<String, Object>();
 268                 map = (Map<String, Object>) gson.fromJson(response, map.getClass());
 269
 270                 Resource resource = gson.fromJson(response, Resource.class);
 271
 272                 Map<String, ArtifactDefinition> artifacts = resource.getArtifacts();
 273                 Map<String, InterfaceDefinition> interfaces = null;
 274
 275                 if (interfaze != null) {
 276                         interfaces = resource.getInterfaces();
 277                         Map<String, Operation> operation = interfaces.get(interfaze).getOperationsMap();
 278                         // operation.get("configure").getUniqueId();
 279                 }
 280
 281                 validateField(map, RespJsonKeysEnum.RESOURCE_NAME.getRespJsonKeyName(), resourceRespJavaObject.getName());
 282                 validateField(map, RespJsonKeysEnum.RESOURCE_DESC.getRespJsonKeyName(),
 283                                 resourceRespJavaObject.getDescription());
 284                 // validateField(map, RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName(),
 285                 // resourceRespJavaObject.getCategories());
 286                 validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(), resourceRespJavaObject.getDerivedFrom());
 287                 validateField(map, RespJsonKeysEnum.VENDOR_NAME.getRespJsonKeyName(), resourceRespJavaObject.getVendorName());
 288                 validateField(map, RespJsonKeysEnum.VENDOR_RELEASE.getRespJsonKeyName(),
 289                                 resourceRespJavaObject.getVendorRelease());
 290                 validateField(map, RespJsonKeysEnum.CONTACT_ID.getRespJsonKeyName(), resourceRespJavaObject.getContactId());
 291                 validateField(map, RespJsonKeysEnum.ICON.getRespJsonKeyName(), resourceRespJavaObject.getIcon());
 292                 validateField(map, RespJsonKeysEnum.IS_ABSTRACT.getRespJsonKeyName(),
 293                                 Boolean.valueOf(resourceRespJavaObject.getAbstractt()));
 294                 validateField(map, RespJsonKeysEnum.HIGHEST_VERSION.getRespJsonKeyName(),
 295                                 Boolean.valueOf(resourceRespJavaObject.getIsHighestVersion()));
 296                 validateField(map, RespJsonKeysEnum.UNIQUE_ID.getRespJsonKeyName(), resourceRespJavaObject.getUniqueId());
 297                 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceRespJavaObject.getVersion());
 298                 validateField(map, RespJsonKeysEnum.LIFE_CYCLE_STATE.getRespJsonKeyName(),
 299                                 resourceRespJavaObject.getLifecycleState());
 300                 validateField(map, RespJsonKeysEnum.TAGS.getRespJsonKeyName(), resourceRespJavaObject.getTags());
 301                 validateField(map, RespJsonKeysEnum.CREATOR_ATT_UID.getRespJsonKeyName(),
 302                                 resourceRespJavaObject.getCreatorUserId());
 303                 validateField(map, RespJsonKeysEnum.CREATOR_FULL_NAME.getRespJsonKeyName(),
 304                                 resourceRespJavaObject.getCreatorFullName());
 305                 validateField(map, RespJsonKeysEnum.LAST_UPDATER_ATT_UID.getRespJsonKeyName(),
 306                                 resourceRespJavaObject.getLastUpdaterUserId());
 307                 validateField(map, RespJsonKeysEnum.LAST_UPDATER_FULL_NAME.getRespJsonKeyName(),
 308                                 resourceRespJavaObject.getLastUpdaterFullName());
 309
 310                 // validate number of artifacts
 311                 if (resourceRespJavaObject.getArtifacts() != null) {
 312
 313                         // assertEquals("check number of artifacts",
 314                         // resourceRespJavaObject.getArtifacts().size(), artifacts.size());
 315                         int iterNum = -1;
 316                         ArrayList<String> myArtifacats = new ArrayList<String>();
 317                         Iterator it = artifacts.entrySet().iterator();
 318                         while (it.hasNext()) {
 319                                 iterNum++;
 320                                 Map.Entry pair = (Map.Entry) it.next();
 321                                 // System.out.println(pair.getKey() + " = " + pair.getValue());
 322                                 ArtifactDefinition myArtifact = artifacts.get(pair.getKey());
 323                                 myArtifacats.add(myArtifact.getEsId());
 324                                 it.remove(); // avoids a ConcurrentModificationException
 325                         }
 326                         // assertTrue("check service contains
 327                         // artifacts",myArtifacats.containsAll(resourceRespJavaObject.getArtifacts()));
 328                 }
 329
 330                 // validate number of interfaces:
 331
 332                 if (interfaze != null) {
 333                         assertEquals("check number of interfaces", resourceRespJavaObject.getInterfaces().size(),
 334                                         interfaces.size());
 335                 }
 336
 337         }
 338
 339         public static boolean validateResourceIsAbstartct(List<Resource> resourceList, Boolean bool) {
 340                 if (resourceList != null && resourceList.size() > 0) {
 341                         for (Resource resource : resourceList) {
 342                                 if (resource.isAbstract().equals(bool))
 343                                         continue;
 344                                 else
 345                                         return false;
 346                         }
 347                 } else
 348                         return false;
 349                 return true;
 350         }
 351
 352         public static void validateResourceVersion(Resource resource, String expectedVersion) {
 353                 if (resource != null && !resource.equals("")) {
 354                         assertTrue("expected resource version is: " + expectedVersion + ", but actual is: " + resource.getVersion(),
 355                                         resource.getVersion().equals(expectedVersion));
 356                 }
 357         }
 358 }