test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/utils/validation/CsarValidationUtils.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.assertTrue;
  24
  25 import java.io.File;
  26 import java.nio.charset.StandardCharsets;
  27 import java.nio.file.Files;
  28 import java.nio.file.Path;
  29 import java.util.ArrayList;
  30 import java.util.List;
  31 import java.util.Map;
  32
  33 import org.openecomp.sdc.be.model.Resource;
  34 import org.openecomp.sdc.ci.tests.datatypes.GroupHeatMetaDefinition;
  35 import org.openecomp.sdc.ci.tests.datatypes.HeatMetaFirstLevelDefinition;
  36 import org.openecomp.sdc.ci.tests.datatypes.TypeHeatMetaDefinition;
  37 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  38 import org.openecomp.sdc.ci.tests.utils.CsarParserUtils;
  39 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  40 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  41 import org.openecomp.sdc.ci.tests.utils.rest.ImportRestUtils;
  42 import org.openecomp.sdc.common.rest.api.RestResponseAsByteArray;
  43 import org.openecomp.sdc.common.util.ZipUtil;
  44
  45 public class CsarValidationUtils {
  46
  47         public static void validateCsarVfArtifact(String csarUUID, Resource resource) throws Exception {
  48
  49                 List<TypeHeatMetaDefinition> listTypeHeatMetaDefinition = CsarParserUtils.getListTypeHeatMetaDefinition(csarUUID);
  50                 assertTrue(
  51                                 "check group count, expected: " + getGroupCount(listTypeHeatMetaDefinition) + ", actual: "
  52                                                 + resource.getGroups().size(),
  53                                 getGroupCount(listTypeHeatMetaDefinition) == resource.getGroups().size());
  54                 assertTrue(
  55                                 "check artifact count, expected: " + getArtifactCount(listTypeHeatMetaDefinition, false) + ", actual: "
  56                                                 + resource.getDeploymentArtifacts().size(),
  57                                 getArtifactCount(listTypeHeatMetaDefinition, false) == resource.getDeploymentArtifacts().size());
  58
  59         }
  60
  61         /*public static List<TypeHeatMetaDefinition> getListTypeHeatMetaDefinition(String csarUUID) throws Exception {
  62
  63                 String artifactHeatMetaLocation = "Artifacts/HEAT.meta";
  64                 JSONParser parser = new JSONParser();
  65                 String csarPayload = getCsarPayload(csarUUID, artifactHeatMetaLocation);
  66                 if (csarPayload != null) {
  67                         Object parse = parser.parse(csarPayload);
  68                         JSONObject jsonObject = (JSONObject) parse;
  69                         JSONObject jsonObjectImportStructure = (JSONObject) jsonObject.get("importStructure");
  70                         List<TypeHeatMetaDefinition> listHeatMetaDefenition = new ArrayList<TypeHeatMetaDefinition>();
  71                         listHeatMetaDefenition = getArtifactsByGroup(jsonObjectImportStructure, listHeatMetaDefenition);
  72                         return listHeatMetaDefenition;
  73                 }
  74                 return null;
  75
  76         }*/
  77
  78         /*public static List<TypeHeatMetaDefinition> getListTypeHeatMetaDefinition(File csarUUID) throws Exception {
  79
  80                 String artifactHeatMetaLocation = "Artifacts/HEAT.meta";
  81                 JSONParser parser = new JSONParser();
  82                 String csarPayload = getCsarPayload(csarUUID, artifactHeatMetaLocation);
  83                 if (csarPayload != null) {
  84                         Object parse = parser.parse(csarPayload);
  85                         JSONObject jsonObject = (JSONObject) parse;
  86                         JSONObject jsonObjectImportStructure = (JSONObject) jsonObject.get("importStructure");
  87                         List<TypeHeatMetaDefinition> listHeatMetaDefenition = new ArrayList<TypeHeatMetaDefinition>();
  88                         listHeatMetaDefenition = getArtifactsByGroup(jsonObjectImportStructure, listHeatMetaDefenition);
  89                         return listHeatMetaDefenition;
  90                 }
  91                 return null;
  92
  93         }*/
  94
  95         private static Integer getGroupCount(List<TypeHeatMetaDefinition> listHeatMetaDefenition) {
  96                 int count = 0;
  97                 for (TypeHeatMetaDefinition typeHeatMetaDefinition : listHeatMetaDefenition) {
  98                         count = count + typeHeatMetaDefinition.getGroupHeatMetaDefinition().size();
  99                 }
 100                 return count;
 101         }
 102
 103         private static Integer getArtifactCount(List<TypeHeatMetaDefinition> listHeatMetaDefenition, Boolean isEnvIncluded) {
 104                 int count = 0;
 105                 List<HeatMetaFirstLevelDefinition> uniqeArtifactList = new ArrayList<>();
 106
 107                 for (TypeHeatMetaDefinition typeHeatMetaDefinition : listHeatMetaDefenition) {
 108                         for (GroupHeatMetaDefinition groupHeatMetaDefinition : typeHeatMetaDefinition
 109                                         .getGroupHeatMetaDefinition()) {
 110                                 if (isEnvIncluded) {
 111                                         count = count + groupHeatMetaDefinition.getArtifactList().size();
 112                                 } else {
 113                                         for (HeatMetaFirstLevelDefinition fileName : groupHeatMetaDefinition.getArtifactList()) {
 114                                                 if (!fileName.getFileName().contains(".env") && !uniqeArtifactList.contains(fileName)) {
 115                                                         uniqeArtifactList.add(fileName);
 116                                                         count = count + 1;
 117                                                 }
 118                                         }
 119                                 }
 120                         }
 121                 }
 122                 return count;
 123         }
 124
 125         /*protected static List<TypeHeatMetaDefinition> getArtifactsByGroup(JSONObject jsonObjectImportStructure, List<TypeHeatMetaDefinition> listHeatMetaDefenition) {
 126
 127                 @SuppressWarnings("unchecked")
 128                 Set<Object> typeSet = jsonObjectImportStructure.keySet();
 129                 for (Object type : typeSet) {
 130                         TypeHeatMetaDefinition heatMetaDefenition = new TypeHeatMetaDefinition();
 131                         log.debug(type.toString());
 132                         log.debug("{}", jsonObjectImportStructure.get(type));
 133                         JSONArray array = (JSONArray) jsonObjectImportStructure.get(type);
 134                         heatMetaDefenition.setTypeName((String) type);
 135                         List<GroupHeatMetaDefinition> groupHeatMetaDefinitions = new ArrayList<GroupHeatMetaDefinition>();
 136                         heatMetaDefenition.setGroupHeatMetaDefinition(fetchArtifactByGroupFromJsonArray(array, groupHeatMetaDefinitions, true, false));
 137                         listHeatMetaDefenition.add(heatMetaDefenition);
 138                 }
 139                 return listHeatMetaDefenition;
 140         }*/
 141
 142 /*      protected static List<GroupHeatMetaDefinition> fetchArtifactByGroupFromJsonArray(JSONArray array, List<GroupHeatMetaDefinition> listGroupHeatMetaDefinition, Boolean openNewGroup, Boolean isNested) {
 143
 144                 GroupHeatMetaDefinition groupHeatMetaDefinition;
 145
 146                 if (array != null) {
 147                         for (int i = 0; i < array.size(); i++) {
 148                                 if (openNewGroup) {
 149                                         groupHeatMetaDefinition = new GroupHeatMetaDefinition();
 150                                         int groupNumber = listGroupHeatMetaDefinition.size() + 1;
 151                                         log.debug("groupName={}", groupNumber);
 152                                         groupHeatMetaDefinition.setGroup(groupNumber);
 153                                         listGroupHeatMetaDefinition.add(groupHeatMetaDefinition);
 154                                         PropertyHeatMetaDefinition propertyHeatMetaDefinition = new PropertyHeatMetaDefinition();
 155                                         propertyHeatMetaDefinition.setName("isBase");
 156                                         propertyHeatMetaDefinition.setValue(false);
 157                                         groupHeatMetaDefinition.setPropertyHeatMetaDefinition(propertyHeatMetaDefinition);
 158                                 }
 159                                 groupHeatMetaDefinition = listGroupHeatMetaDefinition.get(listGroupHeatMetaDefinition.size() - 1);
 160                                 JSONObject jsonObject = (JSONObject) array.get(i);
 161                                 fetchArtifactByGroupFromJsonObject(listGroupHeatMetaDefinition, groupHeatMetaDefinition, jsonObject, isNested);
 162                         }
 163                 }
 164                 return listGroupHeatMetaDefinition;
 165         }*/
 166
 167
 168         /*public static void fetchArtifactByGroupFromJsonObject(List<GroupHeatMetaDefinition> listGroupHeatMetaDefinition, GroupHeatMetaDefinition groupHeatMetaDefinition, JSONObject jsonObject, Boolean isNested) {
 169                 @SuppressWarnings("unchecked")
 170                 Set<Object> groupsKey = jsonObject.keySet();
 171                 for (Object groupKey : groupsKey) {
 172                         String groupKeyStr = (String) groupKey;
 173                         if (groupKeyStr.equals("isBase")) {
 174                                 PropertyHeatMetaDefinition propertyHeatMetaDefinition = new PropertyHeatMetaDefinition();
 175                                 propertyHeatMetaDefinition.setName(groupKeyStr);
 176                                 propertyHeatMetaDefinition.setValue((boolean) jsonObject.get(groupKeyStr));
 177                                 if (!groupHeatMetaDefinition.getPropertyHeatMetaDefinition().equals(propertyHeatMetaDefinition)) {
 178                                         groupHeatMetaDefinition.getPropertyHeatMetaDefinition().setValue((boolean) jsonObject.get(groupKeyStr));
 179                                 }
 180                         }
 181                         if (groupKeyStr.equals("fileName")) {
 182                                 String artifactName = (String) jsonObject.get(groupKeyStr);
 183                                 String artifactType = ArtifactTypeEnum.HEAT_ARTIFACT.getType();
 184                                 if(isNested){
 185                                         artifactType = ArtifactTypeEnum.HEAT_NESTED.getType();
 186                                 }
 187                                 if(jsonObject.get("type") != null && isNested == false){
 188                                         artifactType = (String) jsonObject.get("type");
 189                                 }
 190                                 HeatMetaFirstLevelDefinition heatMetaFirstLevelDefinition = new HeatMetaFirstLevelDefinition(artifactName, artifactType);
 191                                 List<HeatMetaFirstLevelDefinition> listArtifactNames = groupHeatMetaDefinition.getArtifactList();
 192                                 listArtifactNames.add(heatMetaFirstLevelDefinition);
 193                                 groupHeatMetaDefinition.setArtifactList(listArtifactNames);
 194                         } else {
 195                                 if((groupKeyStr.equals("env"))){
 196                                         if (jsonObject.get(groupKeyStr) instanceof JSONObject){
 197                                                 fetchArtifactByGroupFromJsonObject(listGroupHeatMetaDefinition, groupHeatMetaDefinition, (JSONObject) jsonObject.get(groupKeyStr), false);
 198                                         }else{
 199                                                 assertTrue("Expected object is JSONObject, but actual: " + jsonObject.get(groupKeyStr).getClass(), jsonObject.get(groupKeyStr).getClass().equals("JSONObject"));
 200                                         }
 201                                 }
 202                                 if((groupKeyStr.equals("nested"))){
 203                                         if (jsonObject.get(groupKeyStr) instanceof JSONArray){
 204                                                 fetchArtifactByGroupFromJsonArray((JSONArray) jsonObject.get(groupKeyStr), listGroupHeatMetaDefinition, false, true);
 205                                         }else{
 206                                                 assertTrue("Expected object is JSONArray, but actual: " + jsonObject.get(groupKeyStr).getClass(), jsonObject.get(groupKeyStr).getClass().equals("JSONArray"));
 207                                         }
 208
 209                                 }else if (!(groupKeyStr.equals("isBase") || groupKeyStr.equals("type") || groupKeyStr.equals("env"))) {
 210                                         if (jsonObject.get(groupKeyStr) instanceof JSONArray){
 211                                                 fetchArtifactByGroupFromJsonArray((JSONArray) jsonObject.get(groupKeyStr), listGroupHeatMetaDefinition, false, false);
 212                                         }else{
 213                                                 assertTrue("Expected object is JSONArray, but actual: " + jsonObject.get(groupKeyStr).getClass(), jsonObject.get(groupKeyStr).getClass().equals("JSONArray"));
 214                                         }
 215                                 }
 216                         }
 217                 }
 218         }*/
 219
 220         /*public static List<TypeHeatMetaDefinition> getListTypeHeatMetaDefinition(String csarUUID) throws Exception {
 221
 222                 String artifactHeatMetaLocation = "Artifacts/HEAT.meta";
 223                 JSONParser parser = new JSONParser();
 224                 String csarPayload = getCsarPayload(csarUUID, artifactHeatMetaLocation);
 225                 if (csarPayload != null) {
 226                         Object parse = parser.parse(csarPayload);
 227                         JSONObject jsonObject = (JSONObject) parse;
 228                         JSONObject jsonObjectImportStructure = (JSONObject) jsonObject.get("importStructure");
 229                         List<TypeHeatMetaDefinition> listHeatMetaDefenition = new ArrayList<TypeHeatMetaDefinition>();
 230                         listHeatMetaDefenition = getArtifactsByGroup(jsonObjectImportStructure, listHeatMetaDefenition);
 231                         return listHeatMetaDefenition;
 232                 }
 233                 return null;
 234
 235         }
 236
 237         protected static List<TypeHeatMetaDefinition> getArtifactsByGroup(JSONObject jsonObjectImportStructure,
 238                         List<TypeHeatMetaDefinition> listHeatMetaDefenition) {
 239
 240                 @SuppressWarnings("unchecked")
 241                 Set<Object> typeSet = jsonObjectImportStructure.keySet();
 242                 for (Object type : typeSet) {
 243                         TypeHeatMetaDefinition heatMetaDefenition = new TypeHeatMetaDefinition();
 244                         log.debug(type.toString());
 245                         log.debug("{}", jsonObjectImportStructure.get(type));
 246                         JSONArray array = (JSONArray) jsonObjectImportStructure.get(type);
 247                         heatMetaDefenition.setTypeName((String) type);
 248                         List<GroupHeatMetaDefinition> groupHeatMetaDefinitions = new ArrayList<GroupHeatMetaDefinition>();
 249                         heatMetaDefenition.setGroupHeatMetaDefinition(fetchArtifactByGroup(array, groupHeatMetaDefinitions, true));
 250                         listHeatMetaDefenition.add(heatMetaDefenition);
 251                 }
 252                 return listHeatMetaDefenition;
 253         }
 254
 255         protected static List<GroupHeatMetaDefinition> fetchArtifactByGroup(JSONArray array,
 256                         List<GroupHeatMetaDefinition> listGroupHeatMetaDefinition, Boolean openNewGroup) {
 257
 258                 GroupHeatMetaDefinition groupHeatMetaDefinition;
 259
 260                 if (array != null) {
 261                         for (int i = 0; i < array.size(); i++) {
 262                                 if (openNewGroup) {
 263                                         groupHeatMetaDefinition = new GroupHeatMetaDefinition();
 264                                         int groupNumber = listGroupHeatMetaDefinition.size() + 1;
 265                                         log.debug("groupName={}", groupNumber);
 266                                         groupHeatMetaDefinition.setGroup(groupNumber);
 267                                         listGroupHeatMetaDefinition.add(groupHeatMetaDefinition);
 268                                         PropertyHeatMetaDefinition propertyHeatMetaDefinition = new PropertyHeatMetaDefinition();
 269                                         propertyHeatMetaDefinition.setName("isBase");
 270                                         propertyHeatMetaDefinition.setValue(false);
 271                                         groupHeatMetaDefinition.setPropertyHeatMetaDefinition(propertyHeatMetaDefinition);
 272                                 }
 273                                 groupHeatMetaDefinition = listGroupHeatMetaDefinition.get(listGroupHeatMetaDefinition.size() - 1);
 274                                 JSONObject jsonObject = (JSONObject) array.get(i);
 275                                 @SuppressWarnings("unchecked")
 276                                 Set<Object> groupsKey = jsonObject.keySet();
 277                                 for (Object groupKey : groupsKey) {
 278                                         String groupKeyStr = (String) groupKey;
 279                                         if (groupKeyStr.equals("isBase")) {
 280                                                 PropertyHeatMetaDefinition propertyHeatMetaDefinition = new PropertyHeatMetaDefinition();
 281                                                 propertyHeatMetaDefinition.setName(groupKeyStr);
 282                                                 propertyHeatMetaDefinition.setValue((boolean) jsonObject.get(groupKeyStr));
 283                                                 if (!groupHeatMetaDefinition.getPropertyHeatMetaDefinition()
 284                                                                 .equals(propertyHeatMetaDefinition)) {
 285                                                         groupHeatMetaDefinition.getPropertyHeatMetaDefinition()
 286                                                                         .setValue((boolean) jsonObject.get(groupKeyStr));
 287                                                 }
 288                                         }
 289                                         if (groupKeyStr.equals("fileName") || groupKeyStr.equals("env")) {
 290                                                 String artifactName = (String) jsonObject.get(groupKeyStr);
 291                                                 List<String> listArtifactNames = groupHeatMetaDefinition.getArtifactList();
 292                                                 listArtifactNames.add(artifactName);
 293                                                 groupHeatMetaDefinition.setArtifactList(listArtifactNames);
 294                                         } else {
 295                                                 if (!groupKeyStr.equals("isBase")) {
 296                                                         fetchArtifactByGroup((JSONArray) jsonObject.get(groupKeyStr), listGroupHeatMetaDefinition,
 297                                                                         false);
 298                                                 }
 299                                         }
 300                                 }
 301                         }
 302                 }
 303                 return listGroupHeatMetaDefinition;
 304         }
 305
 306         private static Integer getArtifactCount(List<TypeHeatMetaDefinition> listHeatMetaDefenition,
 307                         Boolean isEnvIncluded) {
 308                 int count = 0;
 309                 List<String> uniqeArtifactList = new ArrayList<>();
 310
 311                 for (TypeHeatMetaDefinition typeHeatMetaDefinition : listHeatMetaDefenition) {
 312                         for (GroupHeatMetaDefinition groupHeatMetaDefinition : typeHeatMetaDefinition
 313                                         .getGroupHeatMetaDefinition()) {
 314                                 if (isEnvIncluded) {
 315                                         count = count + groupHeatMetaDefinition.getArtifactList().size();
 316                                 } else {
 317                                         for (String fileName : groupHeatMetaDefinition.getArtifactList()) {
 318                                                 if (!fileName.contains(".env") && !uniqeArtifactList.contains(fileName)) {
 319                                                         uniqeArtifactList.add(fileName);
 320                                                         count = count + 1;
 321                                                 }
 322                                         }
 323                                 }
 324                         }
 325                 }
 326                 return count;
 327         }
 328
 329         private static Integer getGroupCount(List<TypeHeatMetaDefinition> listHeatMetaDefenition) {
 330                 int count = 0;
 331                 for (TypeHeatMetaDefinition typeHeatMetaDefinition : listHeatMetaDefenition) {
 332                         count = count + typeHeatMetaDefinition.getGroupHeatMetaDefinition().size();
 333                 }
 334                 return count;
 335         }
 336
 337         private static String groupNameBuilder(Resource resource) {
 338                 String separator = "::";
 339                 String module = "module-";
 340                 String groupName = resource.getSystemName() + separator + module;
 341                 return groupName;
 342         }
 343
 344         public static void validateCsarVfArtifact(String csarUUID, Resource resource) throws Exception {
 345
 346                 List<TypeHeatMetaDefinition> listTypeHeatMetaDefinition = getListTypeHeatMetaDefinition(csarUUID);
 347                 assertTrue(
 348                                 "check group count, expected: " + getGroupCount(listTypeHeatMetaDefinition) + ", actual: "
 349                                                 + resource.getGroups().size(),
 350                                 getGroupCount(listTypeHeatMetaDefinition) == resource.getGroups().size());
 351                 assertTrue(
 352                                 "check artifact count, expected: " + getArtifactCount(listTypeHeatMetaDefinition, false) + ", actual: "
 353                                                 + resource.getDeploymentArtifacts().size(),
 354                                 getArtifactCount(listTypeHeatMetaDefinition, false) == resource.getDeploymentArtifacts().size());
 355
 356         }
 357
 358         public static void validateToscaDefinitonObjectVsResource(ToscaDefinition toscaDefinition, Resource resource)
 359                         throws Exception {
 360
 361                 assertTrue(
 362                                 "check resource instance count, expected: " + getResourceInstanceCount(toscaDefinition) + ", actual: "
 363                                                 + resource.getComponentInstances().size(),
 364                                 getResourceInstanceCount(toscaDefinition) == resource.getComponentInstances().size());
 365                 assertTrue(
 366                                 "check resource instance relation count, expected: " + getResourceInstanceRelationCount(toscaDefinition)
 367                                                 + ", actual: " + resource.getComponentInstancesRelations().size(),
 368                                 getResourceInstanceRelationCount(toscaDefinition) == resource.getComponentInstancesRelations().size());
 369
 370         }
 371
 372         public static Integer getResourceInstanceCount(ToscaDefinition toscaDefinition) {
 373
 374                 return toscaDefinition.getTopology_template().getNode_templates().size();
 375         }
 376
 377         public static Integer getResourceInstanceRelationCount(ToscaDefinition toscaDefinition) {
 378                 int count = 0;
 379 //              List<ToscaNodeTemplatesTopologyTemplateDefinition> toscaNodeTemplatesTopologyTemplateDefinition = toscaDefinition
 380 //                              .getTopology_template().getToscaNodeTemplatesTopologyTemplateDefinition();
 381                 Map<String,ToscaNodeTemplatesTopologyTemplateDefinition> toscaNodeTemplatesTopologyTemplateDefinition = toscaDefinition.getTopology_template().getNode_templates();
 382                 for (int i = 0; i < toscaNodeTemplatesTopologyTemplateDefinition.size(); i++) {
 383 //                      List<ToscaRequirementsNodeTemplatesDefinition> requirements = toscaNodeTemplatesTopologyTemplateDefinition.get(i).getRequirements();
 384
 385                         for(Entry entry: toscaDefinition.getTopology_template().getNode_templates().entrySet() ){
 386                                 if (entry.getValue().equals("requirements")){
 387
 388                                 }
 389                         }
 390
 391                         if (requirements != null) {
 392                                 for (ToscaRequirementsNodeTemplatesDefinition requirement : requirements) {
 393                                         if (requirement.getNode() != null) {
 394                                                 count = count + 1;
 395                                         }
 396                                 }
 397                         }
 398                 }
 399                 return count;
 400         }
 401
 402         // not finished yet
 403         private static void validateCsarVfgroup(String csarUUID, Resource resource) {
 404
 405                 List<GroupDefinition> groups = resource.getGroups();
 406                 for (GroupDefinition groupDefinition : groups) {
 407                         List<String> artifacts = groupDefinition.getArtifacts();
 408                         assertTrue("group description is null", groupDefinition.getDescription() != null);
 409                         assertTrue("InvariantUUID is null", groupDefinition.getInvariantUUID() != null);
 410                         // groupDefinition.getMembers();
 411                         assertTrue(
 412                                         "name format mismatch, expected: " + groupNameBuilder(resource) + "[0-9], actual: "
 413                                                         + groupDefinition.getName(),
 414                                         groupDefinition.getName().contains(groupNameBuilder(resource)));
 415                         // groupDefinition.getProperties();
 416                         // groupDefinition.getPropertyValueCounter();
 417                         assertTrue(groupDefinition.getType().equals(getGroupType()));
 418                 }
 419
 420                 String expectedCsarUUID = csarUUID;
 421                 // String expectedToscaResourceName = "org.openecomp.resource.vf." +
 422                 // WordUtils.capitalize(resourceDetails.getName().toLowerCase());
 423                 //
 424                 // assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID,
 425                 // resource.getCsarUUID()),
 426                 // expectedCsarUUID.equals(resource.getCsarUUID()));
 427                 // assertTrue("toscaResourceName : " +
 428                 // buildAssertMessage(expectedToscaResourceName,
 429                 // resource.getToscaResourceName()),
 430                 // expectedToscaResourceName.equals(resource.getToscaResourceName()));
 431                 //
 432                 // RestResponse getResourceResponse =
 433                 // ResourceRestUtils.getResource(resource.getUniqueId());
 434                 // Resource getResource =
 435                 // ResponseParser.parseToObjectUsingMapper(getResourceResponse.getResponse(),
 436                 // Resource.class);
 437                 // assertTrue("csarUUID : " + buildAssertMessage(expectedCsarUUID,
 438                 // getResource.getCsarUUID()),
 439                 // expectedCsarUUID.equals(getResource.getCsarUUID()));
 440                 // assertTrue("toscaResourceName : " +
 441                 // buildAssertMessage(expectedToscaResourceName,
 442                 // getResource.getToscaResourceName()),
 443                 // expectedToscaResourceName.equals(getResource.getToscaResourceName()));
 444
 445         }
 446
 447         private static String getGroupType() {
 448                 return "org.openecomp.groups.VfModule";
 449         }
 450 */
 451
 452
 453
 454
 455 }