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