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