ui-ci/src/main/java/org/openecomp/sdc/ci/tests/verificator/VFCArtifactVerificator.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.verificator;
  22
  23 import static org.testng.Assert.assertTrue;
  24
  25 import java.util.ArrayList;
  26 import java.util.LinkedList;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.stream.Collectors;
  30
  31 import org.json.simple.JSONArray;
  32 import org.json.simple.JSONObject;
  33 import org.json.simple.JSONValue;
  34 import org.openecomp.sdc.be.model.User;
  35 import org.openecomp.sdc.ci.tests.datatypes.HeatMetaFirstLevelDefinition;
  36 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  37 import org.openecomp.sdc.ci.tests.datatypes.VFCArtifact;
  38 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  39 import org.openecomp.sdc.ci.tests.execute.setup.ExtentTestActions;
  40 import org.openecomp.sdc.ci.tests.utilities.RestCDUtils;
  41 import org.testng.Assert;
  42
  43 import com.aventstack.extentreports.Status;
  44
  45 public class VFCArtifactVerificator {
  46
  47         private static final String ARTIFACTS = "artifacts";
  48         private static final String DEPLOYMENT_ARTIFACTS = "deploymentArtifacts";
  49         private static List<VFCArtifact> vfcArtifactList = new ArrayList<VFCArtifact>();
  50         private static JSONObject jsonResource;
  51
  52         public static void verifyVFCArtifactsNotInVFArtifactList(ResourceReqDetails resource , User user, RestResponse optionalGetResponse, Map<String, LinkedList<HeatMetaFirstLevelDefinition>> expectedArtifactMap){
  53                 ExtentTestActions.log(Status.INFO, "Verifying that VFC artifacts are not as part of VF artifacts.");
  54                 LinkedList<HeatMetaFirstLevelDefinition> expectedDeploymentArtifacts = expectedArtifactMap.get(DEPLOYMENT_ARTIFACTS);
  55                 LinkedList<HeatMetaFirstLevelDefinition> expectedInformationalArtifacts = expectedArtifactMap.get(ARTIFACTS);
  56
  57                 Map<String, Object> vfDepArtifacts = getVFDeploymentArtifacts(resource, user, optionalGetResponse);
  58                 for (Object artifact : vfDepArtifacts.values()){
  59                         JSONObject acArtifact = ((JSONObject) JSONValue.parse(artifact.toString()));
  60                         String acArtifactName = acArtifact.get("artifactName").toString();
  61
  62                         for(HeatMetaFirstLevelDefinition exDepArtifact : expectedDeploymentArtifacts){
  63                                 assertTrue(!exDepArtifact.getType().equals(acArtifactName));
  64                         }
  65                 }
  66
  67                 Map<String, Object> vfInfoArtifacts = getVFInforamtionalArtifacts(resource, user, optionalGetResponse);
  68                 for (Object artifact : vfInfoArtifacts.values()){
  69                         JSONObject acArtifact = ((JSONObject) JSONValue.parse(artifact.toString()));
  70                         if (acArtifact.containsKey("artifactName")){
  71                                 String acArtifactName  = acArtifact.get("artifactName").toString();
  72
  73                                 for(HeatMetaFirstLevelDefinition exInfoArtifact : expectedInformationalArtifacts){
  74                                         assertTrue(!exInfoArtifact.getType().equals(acArtifactName));
  75                                 }
  76                         }
  77
  78
  79                 }
  80
  81
  82
  83         }
  84
  85         public static void verifyVfcArtifactUpdated(String instanceName, ResourceReqDetails resource, User user){
  86                 ExtentTestActions.log(Status.INFO, "Verifying VFC artifacts are updated.");
  87                 List<VFCArtifact> vfcArtifactsBeforeUpdate = getVfcArtifactList();
  88
  89                 setVfcArtifactList(new ArrayList<VFCArtifact>());
  90                 setActualVfcArtifactList(instanceName, resource, user);
  91
  92                 for (VFCArtifact artifact : vfcArtifactsBeforeUpdate){
  93                         String artifactnameBeforeUpdate = artifact.getArtifactname();
  94                         for (VFCArtifact newArtifact : vfcArtifactList){
  95                                 String artifactnameAfterUpdate = newArtifact.getArtifactname();
  96                                 if (artifactnameBeforeUpdate.equals(artifactnameAfterUpdate)){
  97                                         String artifactUUIDAfterUpdate = newArtifact.getArtifactUUID();
  98                                         assertTrue(!artifactUUIDAfterUpdate.equals(artifact.getArtifactUUID()));
  99
 100                                         int artifactVersionAfterUpdate = Integer.parseInt(newArtifact.getArtifactVersion());
 101                                         int artifactVersionBeforeUpdate = Integer.parseInt(artifact.getArtifactVersion());
 102                                         assertTrue(artifactVersionAfterUpdate == artifactVersionBeforeUpdate + 1);
 103
 104
 105                                         vfcArtifactList.remove(newArtifact);
 106
 107                                         ExtentTestActions.log(Status.INFO, "VFC artifacts are updated and verified.");
 108
 109                                         break;
 110                                 }
 111                         }
 112                 }
 113
 114
 115                 assertTrue(vfcArtifactList.size() == 0);
 116
 117         }
 118
 119         public static void verifyVFCArtifactNotChanged(String instanceName, ResourceReqDetails resource, User user){
 120                 ExtentTestActions.log(Status.INFO, "Verifying VFC artifacts are not chaned after update.");
 121                 List<VFCArtifact> vfcArtifactsBeforeUpdate = getVfcArtifactList();
 122
 123                 setVfcArtifactList(new ArrayList<VFCArtifact>());
 124                 setActualVfcArtifactList(instanceName, resource, user);
 125
 126                 for (VFCArtifact artifact : vfcArtifactsBeforeUpdate){
 127                         String artifactnameBeforeUpdate = artifact.getArtifactname();
 128                         for (VFCArtifact newArtifact : vfcArtifactList){
 129                                 String artifactnameAfterUpdate = newArtifact.getArtifactname();
 130                                 if (artifactnameBeforeUpdate.equals(artifactnameAfterUpdate)){
 131                                         String artifactUUIDAfterUpdate = newArtifact.getArtifactUUID();
 132                                         assertTrue(artifactUUIDAfterUpdate.equals(artifact.getArtifactUUID()));
 133
 134                                         int artifactVersionAfterUpdate = Integer.parseInt(newArtifact.getArtifactVersion());
 135                                         int artifactVersionBeforeUpdate = Integer.parseInt(artifact.getArtifactVersion());
 136                                         assertTrue(artifactVersionAfterUpdate == artifactVersionBeforeUpdate);
 137
 138                                         vfcArtifactList.remove(newArtifact);
 139                                         break;
 140                                 }
 141                         }
 142                 }
 143
 144
 145                 assertTrue(vfcArtifactList.size() == 0);
 146
 147         }
 148
 149         public static void verifyNoVfcArtifacts(ResourceReqDetails resource , User user, RestResponse optionalGetResponse){
 150                 ExtentTestActions.log(Status.INFO, "Verifying that there are no VFC artifacts at all.");
 151                 JSONArray jArr = getVFInstances(resource, user, optionalGetResponse);
 152                 for (Object instanceObj : jArr){
 153                         JSONObject instance = (JSONObject) JSONValue.parse(instanceObj.toString());
 154                         List<String> actualDeploymentArtifacts = getActualVfcInstanceArtifactsFromJson(DEPLOYMENT_ARTIFACTS, instance);
 155
 156                         assertTrue(actualDeploymentArtifacts == null || actualDeploymentArtifacts.size() == 0);
 157                 }
 158         }
 159
 160         public static void verifyVfcArtifacts(ResourceReqDetails resource , User user, String instanceName, Map<String, LinkedList<HeatMetaFirstLevelDefinition>> expectedArtifactMap,
 161                         RestResponse optionalGetResponse){
 162                 ExtentTestActions.log(Status.INFO, "Verifying VFC artifacts for instance named " + instanceName);
 163
 164                 String exCompName = instanceName.split(".vfc.")[1].toLowerCase();
 165                 String exName = instanceName.split(".heat.")[1].toLowerCase();
 166
 167                 JSONArray jArr = getVFInstances(resource, user, optionalGetResponse);
 168                 int jArrSize = jArr.size();
 169
 170                 for (Object instanceObj : jArr){
 171                         JSONObject instance = (JSONObject) JSONValue.parse(instanceObj.toString());
 172                         String componentName = instance.get("componentName").toString().toLowerCase();
 173                         String name = instance.get("name").toString().toLowerCase();
 174
 175                         if (componentName.contains(exCompName) || name.toLowerCase().equals(exName)){
 176
 177                                 List<String> actualDeploymentArtifacts = getActualVfcInstanceArtifactsFromJson(DEPLOYMENT_ARTIFACTS, instance);
 178                                 LinkedList<HeatMetaFirstLevelDefinition> expectedDeploymentArtifacts = expectedArtifactMap.get(DEPLOYMENT_ARTIFACTS);
 179                                 checkVFCArtifactsExist(expectedDeploymentArtifacts, actualDeploymentArtifacts);
 180
 181
 182                                 List<String> actualInformationalArtifacts = getActualVfcInstanceArtifactsFromJson(ARTIFACTS, instance);
 183                                 LinkedList<HeatMetaFirstLevelDefinition> expectedInformationalArtifacts = expectedArtifactMap.get(ARTIFACTS);
 184                                 checkVFCArtifactsExist(expectedInformationalArtifacts, actualInformationalArtifacts);
 185
 186                                 jArr.remove(instanceObj);
 187
 188                                 ExtentTestActions.log(Status.INFO, "VFC artifacts for instance named " + instanceName + "are verified.");
 189
 190                                 break;
 191                         }
 192                 }
 193
 194                 assertTrue(jArr.size() == jArrSize - 1, "Instance " + instanceName + " was not found and tested");
 195
 196         }
 197
 198
 199
 200         private static JSONArray getVFInstances(ResourceReqDetails resource, User user, RestResponse response) {
 201
 202                 jsonResource = getVFAsJsonObject(resource, user, response);
 203                 JSONArray jArr = (JSONArray) jsonResource.get("componentInstances");
 204                 return jArr;
 205         }
 206
 207         private static Map<String, Object> getVFDeploymentArtifacts(ResourceReqDetails resource, User user, RestResponse response) {
 208
 209                 jsonResource = getVFAsJsonObject(resource, user, response);
 210                 Map<String, Object> jArr = (Map<String, Object>) jsonResource.get(DEPLOYMENT_ARTIFACTS);
 211                 return jArr;
 212         }
 213
 214         private static Map<String, Object> getVFInforamtionalArtifacts(ResourceReqDetails resource, User user, RestResponse response) {
 215
 216                 jsonResource = getVFAsJsonObject(resource, user, response);
 217                 Map<String, Object> jArr = (Map<String, Object>) jsonResource.get(ARTIFACTS);
 218                 return jArr;
 219         }
 220
 221         private static JSONObject getVFAsJsonObject(ResourceReqDetails resource, User user, RestResponse response) {
 222                 if (response == null){
 223                         resource.setUniqueId(null);
 224                         response = RestCDUtils.getResource(resource, user);
 225                         assertTrue(response.getErrorCode().intValue() == 200);
 226                         getVFAsJsonObject(resource, user, response);
 227                 }
 228
 229                 String responseAfterDrag = response.getResponse();
 230                 jsonResource = (JSONObject) JSONValue.parse(responseAfterDrag);
 231                 return jsonResource;
 232         }
 233
 234
 235
 236         private static List<String> getActualVfcInstanceArtifactsFromJson(String artifactKind, JSONObject instanceFromJson){
 237                 Object actualtObject = instanceFromJson.get(artifactKind);
 238                 if (actualtObject != null){
 239                         JSONObject actualJsonObject = (JSONObject) JSONValue.parse(actualtObject.toString());
 240                         List<String> actualArtifacts = (List<String>) actualJsonObject.keySet().stream().map(e -> actualJsonObject.get(e).toString()).collect(Collectors.toList());
 241                         return actualArtifacts;
 242                 }
 243                 return null;
 244         }
 245
 246         private static void checkVFCArtifactsExist(LinkedList<HeatMetaFirstLevelDefinition> expectedArtifacts, List<String> actualArtifacts) {
 247                 if (expectedArtifacts == null){
 248                         return;
 249                 }
 250
 251                 if (expectedArtifacts.size() != actualArtifacts.size()){
 252                         ExtentTestActions.log(Status.FAIL, "Expected and actual VFC artifacts lists size are not the same. Expected size: " + expectedArtifacts.size() + " , actual size: " + actualArtifacts.size());
 253                         Assert.fail("Expected and actual VFC artifacts lists size are not the same. Expected size: " + expectedArtifacts.size() + " , actual size: " + actualArtifacts.size());
 254                 }
 255
 256                 List<String> types = new ArrayList<String>();
 257                 List<String> fileNames = new ArrayList<String>();
 258                 for (HeatMetaFirstLevelDefinition exArtifact : expectedArtifacts){
 259
 260                                 fileNames.add(exArtifact.getFileName());
 261                                 types.add(exArtifact.getType());
 262
 263                 }
 264
 265                 for (int i = 0 ; i < actualArtifacts.size() ; i++){
 266                         String actualArtifactsString = actualArtifacts.get(i);
 267                         JSONObject acArtifact = ((JSONObject) JSONValue.parse(actualArtifactsString));
 268
 269                         String acArtifactFileName = acArtifact.get("artifactName").toString();
 270                         String acArtifactType = acArtifact.get("artifactType").toString();
 271
 272                         assertTrue(types.contains(acArtifactType), "List does not contain " + acArtifactType);
 273                         assertTrue(fileNames.contains(acArtifactFileName), "List does not contain " + acArtifactFileName);
 274
 275                         types.remove(acArtifactType);
 276                         fileNames.remove(acArtifactFileName);
 277
 278                 }
 279
 280                 assertTrue(types.size() == 0);
 281                 assertTrue(fileNames.size() == 0);
 282
 283         }
 284
 285         public static List<VFCArtifact> getVfcArtifactList(){
 286                 return vfcArtifactList;
 287         }
 288
 289
 290         public static void setVfcArtifactList(List<VFCArtifact> vfcArtifactList) {
 291                 VFCArtifactVerificator.vfcArtifactList = vfcArtifactList;
 292         }
 293
 294         public static void setActualVfcArtifactList(String instanceName, ResourceReqDetails resource , User user) {
 295                 String exCompName = instanceName.split(".vfc.")[1].toLowerCase();
 296                 String exName = instanceName.split(".heat.")[1].toLowerCase();
 297
 298                 JSONArray jArr = getVFInstances(resource, user, null);
 299
 300                 for (Object instanceObj : jArr){
 301                         JSONObject instance = (JSONObject) JSONValue.parse(instanceObj.toString());
 302                         String componentName = instance.get("componentName").toString().toLowerCase();
 303                         String name = instance.get("name").toString().toLowerCase();
 304
 305                         if (componentName.contains(exCompName) || name.toLowerCase().equals(exName)){
 306                                 List<String> actualDeploymentArtifacts = getActualVfcInstanceArtifactsFromJson(DEPLOYMENT_ARTIFACTS, instance);
 307                                 List<String> actualInformationalArtifacts = getActualVfcInstanceArtifactsFromJson(ARTIFACTS, instance);
 308
 309                                 if (actualDeploymentArtifacts != null){
 310                                         for (int i = 0 ; i < actualDeploymentArtifacts.size() ; i++){
 311                                                 String actualArtifactsString = actualDeploymentArtifacts.get(i);
 312                                                 JSONObject acArtifact = ((JSONObject) JSONValue.parse(actualArtifactsString));
 313
 314                                                 if (acArtifact.containsKey("artifactName")){
 315                                                         String acArtifactType = acArtifact.get("artifactName").toString();
 316                                                         String acArtifactFileName = acArtifact.get("artifactType").toString();
 317                                                         String acArtifactUUID = acArtifact.get("artifactUUID").toString();
 318                                                         String acArtifactVersion = acArtifact.get("artifactVersion").toString();
 319
 320                                                         vfcArtifactList.add(new VFCArtifact(acArtifactType, acArtifactFileName, acArtifactUUID, acArtifactVersion));
 321                                                 }
 322                                         }
 323                                 }
 324                                 if (actualInformationalArtifacts != null){
 325                                         for (int i = 0 ; i < actualInformationalArtifacts.size() ; i++){
 326                                                 String actualArtifactsString = actualInformationalArtifacts.get(i);
 327                                                 JSONObject acArtifact = ((JSONObject) JSONValue.parse(actualArtifactsString));
 328
 329                                                 if (acArtifact.containsKey("artifactName")){
 330                                                         String acArtifactType = acArtifact.get("artifactName").toString();
 331                                                         String acArtifactFileName = acArtifact.get("artifactType").toString();
 332                                                         String acArtifactUUID = acArtifact.get("artifactUUID").toString();
 333                                                         String acArtifactVersion = acArtifact.get("artifactVersion").toString();
 334                                                         vfcArtifactList.add(new VFCArtifact(acArtifactType, acArtifactFileName, acArtifactUUID, acArtifactVersion));
 335                                                 }
 336
 337
 338                                         }
 339                                 }
 340                         }
 341                 }
 342         }
 343
 344 }
 345
 346
 347