asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/imports/ImportGenericResourceCITest.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.execute.imports;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import java.io.File;
  28 import java.io.IOException;
  29 import java.nio.file.FileSystems;
  30 import java.nio.file.Files;
  31 import java.util.ArrayList;
  32 import java.util.Arrays;
  33 import java.util.HashMap;
  34 import java.util.Iterator;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Map.Entry;
  38
  39 import org.apache.http.HttpStatus;
  40 import org.apache.http.client.ClientProtocolException;
  41 import org.apache.http.client.methods.CloseableHttpResponse;
  42 import org.apache.http.client.methods.HttpPost;
  43 import org.apache.http.entity.ContentType;
  44 import org.apache.http.entity.mime.MultipartEntityBuilder;
  45 import org.apache.http.entity.mime.content.FileBody;
  46 import org.apache.http.entity.mime.content.StringBody;
  47 import org.apache.http.impl.client.CloseableHttpClient;
  48 import org.apache.http.impl.client.HttpClients;
  49 import org.junit.Rule;
  50 import org.junit.rules.TestName;
  51 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  52 import org.openecomp.sdc.be.model.PropertyDefinition;
  53 import org.openecomp.sdc.be.model.Resource;
  54 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  55 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  56 import org.openecomp.sdc.ci.tests.api.Urls;
  57 import org.openecomp.sdc.ci.tests.config.Config;
  58 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  59 import org.openecomp.sdc.ci.tests.datatypes.enums.ImportTestTypesEnum;
  60 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
  61 import org.openecomp.sdc.ci.tests.datatypes.enums.RespJsonKeysEnum;
  62 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  63 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  64 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  65 import org.openecomp.sdc.ci.tests.execute.TODO.ImportCapabilityTypeCITest;
  66 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  67 import org.openecomp.sdc.ci.tests.utils.Utils;
  68 import org.openecomp.sdc.ci.tests.utils.rest.ImportRestUtils;
  69 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  70 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  71 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  72 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  73 import org.slf4j.Logger;
  74 import org.slf4j.LoggerFactory;
  75 import org.testng.annotations.BeforeClass;
  76 import org.testng.annotations.Test;
  77
  78 import com.google.gson.Gson;
  79
  80 import fj.data.Either;
  81
  82 public class ImportGenericResourceCITest extends ComponentBaseTest {
  83         private static Logger log = LoggerFactory.getLogger(ImportGenericResourceCITest.class.getName());
  84         private static final String FILE_NAME_MY_COMPUTE = "tosca.nodes.MyCompute";
  85         private static final String RESOURCE_NAME_UPDATE_COMPUTE = "userUpdateCompute";
  86         private static final String RESOURCE_NAME_MY_COMPUTE = "MyCompute";
  87         private static final String RESOURCE_NAME_USER_COMPUTE = "userCompute";
  88         private static final String FILE_NAME_USER_COMPUTE = "tosca.nodes.userCompute";
  89         private static final String FILE_NAME_USER_VFC = "Derived_VFC";
  90         @Rule
  91         public static TestName name = new TestName();
  92
  93         public ImportGenericResourceCITest() {
  94                 super(name, ImportGenericResourceCITest.class.getName());
  95         }
  96
  97         @BeforeClass
  98         public static void beforeImportClass() throws IOException {
  99                 ImportCapabilityTypeCITest.importAllCapabilityTypes();
 100                 // removeAllNormativeTypeResources();
 101                 // importAllNormativeTypesResources(UserRoleEnum.ADMIN);
 102         }
 103
 104         static Config config = Config.instance();
 105
 106         public static Map<NormativeTypesEnum, Boolean> removeAllNormativeTypeResources() throws ClientProtocolException, IOException {
 107                 Map<NormativeTypesEnum, Boolean> normativeExistInDB = new HashMap<>();
 108
 109                 for (NormativeTypesEnum current : NormativeTypesEnum.values()) {
 110                         Boolean existedBeforeDelete = ImportRestUtils.removeNormativeTypeResource(current);
 111                         normativeExistInDB.put(current, existedBeforeDelete);
 112                 }
 113                 return normativeExistInDB;
 114         }
 115
 116         public static Either<String, Boolean> getNormativeTypeResource(NormativeTypesEnum current) throws ClientProtocolException, IOException {
 117                 return getResource(current.getNormativeName(), "1.0");
 118         }
 119
 120         @Test
 121         public void importAllTestResources() throws Exception {
 122                 for (ImportTestTypesEnum currResource : ImportTestTypesEnum.values()) {
 123                         DbUtils.cleanAllAudits();
 124
 125                         RestResponse importResponse = ImportRestUtils.importTestResource(currResource, UserRoleEnum.ADMIN);
 126                         // System.err.println("import Resource
 127                         // "+"<"+currResource+">"+"response:
 128                         // "+importResponse.getErrorCode());
 129                         ImportRestUtils.validateImportTestTypesResp(currResource, importResponse);
 130                         if (currResource.getvalidateAudit() == true) {
 131                                 // validate audit
 132                                 String baseVersion = "1.0";
 133                                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(currResource.getActionStatus().name());
 134                                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = new ExpectedResourceAuditJavaObject();
 135                                 String auditAction = "ResourceImport";
 136                                 expectedResourceAuditJavaObject.setAction(auditAction);
 137                                 expectedResourceAuditJavaObject.setModifierUid(UserRoleEnum.ADMIN.getUserId());
 138                                 expectedResourceAuditJavaObject.setModifierName(UserRoleEnum.ADMIN.getUserName());
 139                                 expectedResourceAuditJavaObject.setResourceName(currResource.getNormativeName());
 140                                 expectedResourceAuditJavaObject.setResourceType("Resource");
 141                                 expectedResourceAuditJavaObject.setPrevVersion("");
 142                                 expectedResourceAuditJavaObject.setCurrVersion(baseVersion);
 143                                 expectedResourceAuditJavaObject.setPrevState("");
 144                                 expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.toString());
 145                                 expectedResourceAuditJavaObject.setComment(null);
 146                                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 147                                 List<String> variables = (currResource.getErrorParams() != null ? currResource.getErrorParams() : new ArrayList<String>());
 148                                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 149                                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 150                                 AuditValidationUtils.validateAuditImport(expectedResourceAuditJavaObject, auditAction);
 151                         }
 152                 }
 153         }
 154
 155         // -----------------------------------------------------------------------------------
 156         protected void validateMyComputeCapabilities(Map<String, Object> map) {
 157                 assertTrue(map.containsKey("capabilities"));
 158                 Map<String, Object> capabilities = (Map<String, Object>) map.get("capabilities");
 159                 assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
 160                 List<Object> hostCapList = (List<Object>) capabilities.get("tosca.capabilities.Container");
 161                 assertFalse(hostCapList.isEmpty());
 162                 Map<String, Object> hostCap = (Map<String, Object>) hostCapList.get(0);
 163                 validateField(hostCap, "type", "tosca.capabilities.Container");
 164                 validateField(hostCap, "name", "host");
 165                 validateField(hostCap, "validSourceTypes", Arrays.asList(new String[] { "tosca.nodes.SoftwareComponent" }));
 166
 167                 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
 168                 List<Object> endPointCapList = (List<Object>) capabilities.get("tosca.capabilities.Endpoint.Admin");
 169                 assertFalse(endPointCapList.isEmpty());
 170                 Map<String, Object> endPointCap = (Map<String, Object>) endPointCapList.get(0);
 171                 validateField(endPointCap, "name", "endpoint");
 172                 validateField(endPointCap, "type", "tosca.capabilities.Endpoint.Admin");
 173
 174                 assertTrue(capabilities.containsKey("tosca.capabilities.OperatingSystem"));
 175                 List<Object> osCapList = (List<Object>) capabilities.get("tosca.capabilities.OperatingSystem");
 176                 assertFalse(osCapList.isEmpty());
 177                 Map<String, Object> osCap = (Map<String, Object>) osCapList.get(0);
 178                 validateField(osCap, "name", "os");
 179                 validateField(osCap, "type", "tosca.capabilities.OperatingSystem");
 180
 181                 assertTrue(capabilities.containsKey("tosca.capabilities.Scalable"));
 182                 List<Object> scalableCapList = (List<Object>) capabilities.get("tosca.capabilities.Scalable");
 183                 assertFalse(scalableCapList.isEmpty());
 184                 Map<String, Object> scalableCap = (Map<String, Object>) scalableCapList.get(0);
 185                 validateField(scalableCap, "name", "scalable");
 186                 validateField(scalableCap, "type", "tosca.capabilities.Scalable");
 187
 188                 assertTrue(capabilities.containsKey("tosca.capabilities.network.Bindable"));
 189                 List<Object> bindingCapList = (List<Object>) capabilities.get("tosca.capabilities.network.Bindable");
 190                 assertFalse(bindingCapList.isEmpty());
 191                 Map<String, Object> bindingCap = (Map<String, Object>) bindingCapList.get(0);
 192                 validateField(bindingCap, "name", "binding");
 193                 validateField(bindingCap, "type", "tosca.capabilities.network.Bindable");
 194
 195         }
 196
 197         protected void validateMyComputeResource(String resourceName, String resourceVersion, String expectedState) throws ClientProtocolException, IOException {
 198                 Either<String, Boolean> eitherMyCompute = getResource(resourceName, resourceVersion);
 199                 assertTrue(eitherMyCompute.isLeft());
 200                 String testComputeYml = eitherMyCompute.left().value();
 201
 202                 Map<String, Object> map = new HashMap<String, Object>();
 203                 map = (Map<String, Object>) new Gson().fromJson(testComputeYml, map.getClass());
 204
 205                 validateMyComputeBasicFields(map, resourceName, resourceVersion, expectedState);
 206
 207                 validateMyComputeCapabilities(map);
 208
 209                 validateMyComputeRequirements(map);
 210                 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceVersion);
 211
 212         }
 213
 214         protected void validateMyComputeResource(String uid, String resourceName, String resourceVersion, String expectedState) throws ClientProtocolException, IOException {
 215                 RestResponse resourceResponse = ResourceRestUtils.getResource(uid);
 216                 ResourceRestUtils.checkSuccess(resourceResponse);
 217                 String testComputeYml = resourceResponse.getResponse();
 218
 219                 // Either<String, Boolean> eitherMyCompute = getResource(resourceName,
 220                 // resourceVersion);
 221                 // assertTrue( eitherMyCompute.isLeft() );
 222                 // String testComputeYml = eitherMyCompute.left().value();
 223
 224                 Map<String, Object> map = new HashMap<String, Object>();
 225                 map = (Map<String, Object>) new Gson().fromJson(testComputeYml, map.getClass());
 226
 227                 validateMyComputeBasicFields(map, resourceName, resourceVersion, expectedState);
 228
 229                 validateMyComputeCapabilities(map);
 230
 231                 validateMyComputeRequirements(map);
 232                 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceVersion);
 233
 234         }
 235
 236         protected void validateMyComputeResourceAfterUpdate(String uid, String resourceName, String resourceVersion, String expectedState) throws ClientProtocolException, IOException {
 237                 RestResponse resourceResponse = ResourceRestUtils.getResource(uid);
 238                 ResourceRestUtils.checkSuccess(resourceResponse);
 239                 String testComputeYml = resourceResponse.getResponse();
 240
 241                 // Either<String, Boolean> eitherMyCompute = getResource(resourceName,
 242                 // resourceVersion);
 243                 // assertTrue( eitherMyCompute.isLeft() );
 244
 245                 // String testComputeYml = eitherMyCompute.left().value();
 246
 247                 Map<String, Object> map = new HashMap<String, Object>();
 248                 map = (Map<String, Object>) new Gson().fromJson(testComputeYml, map.getClass());
 249
 250                 validateMyComputeBasicFields(map, resourceName, resourceVersion, expectedState);
 251                 validateField(map, RespJsonKeysEnum.DESCRIPTION.getRespJsonKeyName(), "Short description");
 252                 validateField(map, RespJsonKeysEnum.VENDOR_NAME.getRespJsonKeyName(), "UserVendor");
 253                 validateField(map, RespJsonKeysEnum.VENDOR_RELEASE.getRespJsonKeyName(), "1.1.2");
 254
 255                 // validateMyComputeCapabilities(map);
 256                 // AssertJUnit.assertTrue(map.containsKey("capabilities"));
 257                 // Map<String, Object> capabilities = (Map<String, Object>)
 258                 // map.get("capabilities");
 259                 // AssertJUnit.assertTrue(capabilities.containsKey("host"));
 260                 // Map<String, Object> hostCap = (Map<String, Object>)
 261                 // capabilities.get("host");
 262                 // validateField(hostCap, "type", "tosca.capabilities.Container");
 263                 // validateField(hostCap, "validSourceTypes", Arrays.asList(new
 264                 // String[]{"tosca.nodes.SoftwareComponent"}));
 265                 //
 266                 // AssertJUnit.assertTrue(capabilities.containsKey("endpoint"));
 267                 // Map<String, Object> endPointCap = (Map<String, Object>)
 268                 // capabilities.get("endpoint");
 269                 // validateField(endPointCap, "type",
 270                 // "tosca.capabilities.Endpoint.Admin");
 271
 272                 assertTrue(map.containsKey("capabilities"));
 273                 Map<String, Object> capabilities = (Map<String, Object>) map.get("capabilities");
 274                 assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
 275                 List<Object> hostCapList = (List<Object>) capabilities.get("tosca.capabilities.Container");
 276                 assertFalse(hostCapList.isEmpty());
 277                 Map<String, Object> hostCap = (Map<String, Object>) hostCapList.get(0);
 278                 validateField(hostCap, "type", "tosca.capabilities.Container");
 279                 validateField(hostCap, "name", "host");
 280                 validateField(hostCap, "validSourceTypes", Arrays.asList(new String[] { "tosca.nodes.SoftwareComponent" }));
 281
 282                 assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
 283                 List<Object> endPointCapList = (List<Object>) capabilities.get("tosca.capabilities.Endpoint.Admin");
 284                 assertFalse(endPointCapList.isEmpty());
 285                 Map<String, Object> endPointCap = (Map<String, Object>) endPointCapList.get(0);
 286                 validateField(endPointCap, "name", "endpoint");
 287                 validateField(endPointCap, "type", "tosca.capabilities.Endpoint.Admin");
 288
 289                 validateMyComputeRequirements(map);
 290                 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceVersion);
 291
 292         }
 293
 294         protected void validateMyComputeRequirements(Map<String, Object> map) {
 295                 assertTrue(map.containsKey("requirements"));
 296                 Map<String, Object> requirements = (Map<String, Object>) map.get("requirements");
 297
 298                 assertTrue(requirements.containsKey("tosca.capabilities.Attachment"));
 299                 List<Object> localStorageReqList = (List<Object>) requirements.get("tosca.capabilities.Attachment");
 300                 assertFalse(localStorageReqList.isEmpty());
 301                 Map<String, Object> localStorageReq = (Map<String, Object>) localStorageReqList.get(0);
 302                 validateField(localStorageReq, "capability", "tosca.capabilities.Attachment");
 303                 validateField(localStorageReq, "node", "tosca.nodes.BlockStorage");
 304                 validateField(localStorageReq, "relationship", "tosca.relationships.AttachesTo");
 305                 validateField(localStorageReq, "name", "local_storage");
 306         }
 307
 308         protected void validateMyComputeBasicFields(Map<String, Object> map, String resourceName, String resourceVersion, String expectedState) {
 309                 validateField(map, RespJsonKeysEnum.IS_ABSTRACT.getRespJsonKeyName(), false);
 310                 // validateField(map, RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName(),
 311                 // categoryDefinition);
 312                 // validateField(map, RespJsonKeysEnum.UNIQUE_ID.getRespJsonKeyName(),
 313                 // UniqueIdBuilder.buildResourceUniqueId(resourceName,
 314                 // resourceVersion));
 315                 validateField(map, RespJsonKeysEnum.RESOURCE_NAME.getRespJsonKeyName(), resourceName);
 316                 validateField(map, RespJsonKeysEnum.TAGS.getRespJsonKeyName(), Arrays.asList(new String[] { resourceName }));
 317                 validateField(map, RespJsonKeysEnum.LIFE_CYCLE_STATE.getRespJsonKeyName(), expectedState);
 318
 319                 validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(), Arrays.asList(new String[] { "tosca.nodes.Root" }));
 320         }
 321
 322         protected static void validateField(Map<String, Object> map, String jsonField, Object expectedValue) {
 323                 if (expectedValue == null) {
 324                         assertTrue(!map.containsKey(jsonField));
 325                 } else {
 326                         assertTrue("map does not contain field " + jsonField, map.containsKey(jsonField));
 327                         Object foundValue = map.get(jsonField);
 328                         compareElements(expectedValue, foundValue);
 329                 }
 330         }
 331
 332         protected static void compareElements(Object expectedValue, Object foundValue) {
 333                 if (expectedValue instanceof String) {
 334                         assertTrue(foundValue instanceof String);
 335                         assertTrue(foundValue.equals(expectedValue));
 336                 }
 337
 338                 else if (expectedValue instanceof Boolean) {
 339                         assertTrue(foundValue instanceof Boolean);
 340                         assertTrue(foundValue == expectedValue);
 341                 } else if (expectedValue instanceof Map) {
 342                         assertTrue(foundValue instanceof Map);
 343                         Map<String, Object> foundMap = (Map<String, Object>) foundValue;
 344                         Map<String, Object> excpectedMap = (Map<String, Object>) expectedValue;
 345                         assertTrue(foundMap.size() == excpectedMap.size());
 346                         Iterator<String> foundkeyItr = foundMap.keySet().iterator();
 347                         while (foundkeyItr.hasNext()) {
 348                                 String foundKey = foundkeyItr.next();
 349                                 assertTrue(excpectedMap.containsKey(foundKey));
 350                                 compareElements(excpectedMap.get(foundKey), foundMap.get(foundKey));
 351                         }
 352
 353                 } else if (expectedValue instanceof List) {
 354                         assertTrue(foundValue instanceof List);
 355                         List<Object> foundList = (List<Object>) foundValue;
 356                         List<Object> excpectedList = (List<Object>) expectedValue;
 357                         assertTrue(foundList.size() == excpectedList.size());
 358                         for (int i = 0; i < foundList.size(); i++) {
 359                                 compareElements(excpectedList.get(i), foundList.get(i));
 360                         }
 361
 362                 } else if (expectedValue instanceof CategoryDefinition) {
 363                         assertTrue(foundValue instanceof Map);
 364                         CategoryDefinition expCat = (CategoryDefinition) expectedValue;
 365                         Map<String, Object> actCat = (Map<String, Object>) foundValue;
 366                         assertEquals(expCat.getName(), actCat.get("name"));
 367
 368                         // assertEquals(expCat.getSubcategories().get(0).getName(),
 369                         // actCat.get("subcategories").getName());
 370                 } else {
 371                         assertTrue(foundValue.equals(expectedValue));
 372                 }
 373         }
 374
 375         public static void restoreToOriginalState(Map<NormativeTypesEnum, Boolean> originalState, UserRoleEnum userRole) throws IOException {
 376                 removeAllNormativeTypeResources();
 377
 378                 Iterator<Entry<NormativeTypesEnum, Boolean>> iterator = originalState.entrySet().iterator();
 379                 while (iterator.hasNext()) {
 380                         Entry<NormativeTypesEnum, Boolean> entry = iterator.next();
 381                         Boolean isExistBeforeDelete = entry.getValue();
 382                         if (isExistBeforeDelete) {
 383                                 importNormativeResource(entry.getKey(), userRole);
 384                         }
 385                 }
 386
 387         }
 388
 389         public static void importAllNormativeTypesResources(UserRoleEnum userRole) throws IOException {
 390                 for (NormativeTypesEnum currResource : NormativeTypesEnum.values()) {
 391                         Either<String, Boolean> resource = getResource(currResource.getNormativeName(), "1.0");
 392                         if (resource.isRight()) {
 393                                 importNormativeResource(currResource, userRole);
 394                         }
 395                 }
 396
 397         }
 398
 399         protected static Integer importNormativeResource(NormativeTypesEnum resource, UserRoleEnum userRole) throws IOException {
 400                 return importResource(resource.getFolderName(), userRole, true);
 401         }
 402
 403         protected static Integer importResource(String folderName, UserRoleEnum userRole, boolean isNormative) throws IOException {
 404                 Config config = Utils.getConfig();
 405                 CloseableHttpResponse response = null;
 406                 MultipartEntityBuilder mpBuilder = MultipartEntityBuilder.create();
 407
 408                 mpBuilder.addPart("resourceZip", new FileBody(getZipFile(folderName)));
 409                 mpBuilder.addPart("resourceMetadata", new StringBody(getJsonStringOfFile(folderName, folderName + ".json"), ContentType.APPLICATION_JSON));
 410
 411                 String url = String.format(Urls.IMPORT_RESOURCE_NORMATIVE, config.getCatalogBeHost(), config.getCatalogBePort());
 412                 if (!isNormative) {
 413                         url = String.format(Urls.IMPORT_USER_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort());
 414                 }
 415
 416                 CloseableHttpClient client = HttpClients.createDefault();
 417                 try {
 418                         HttpPost httpPost = new HttpPost(url);
 419                         httpPost.addHeader("USER_ID", userRole.getUserId());
 420                         httpPost.setEntity(mpBuilder.build());
 421                         response = client.execute(httpPost);
 422                         return response.getStatusLine().getStatusCode();
 423                 } finally {
 424                         closeResponse(response);
 425                         closeHttpClient(client);
 426
 427                 }
 428         }
 429
 430         public static void closeHttpClient(CloseableHttpClient client) {
 431                 try {
 432                         if (client != null) {
 433                                 client.close();
 434                         }
 435                 } catch (IOException e) {
 436                         log.debug("failed to close client or response: ", e);
 437                 }
 438         }
 439
 440         public static void closeResponse(CloseableHttpResponse response) {
 441                 try {
 442                         if (response != null) {
 443                                 response.close();
 444                         }
 445                 } catch (IOException e) {
 446                         log.debug("failed to close client or response: ", e);
 447                 }
 448         }
 449
 450         protected static String getJsonStringOfFile(String folderName, String fileName) throws IOException {
 451                 String sourceDir = config.getImportResourceConfigDir();
 452                 sourceDir += File.separator + "normative-types";
 453
 454                 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir + File.separator + folderName, fileName);
 455                 byte[] fileContent = Files.readAllBytes(filePath);
 456                 String content = new String(fileContent);
 457                 return content;
 458         }
 459
 460         protected static File getZipFile(String elementName) throws IOException {
 461                 String sourceDir = config.getImportResourceConfigDir();
 462                 sourceDir += File.separator + "normative-types";
 463
 464                 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir + File.separator + elementName, "normative-types-new-" + elementName + ".zip");
 465                 return filePath.toFile();
 466         }
 467
 468         protected static String getTestJsonStringOfFile(String folderName, String fileName) throws IOException {
 469                 String sourceDir = config.getImportResourceTestsConfigDir();
 470                 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir + File.separator + folderName, fileName);
 471                 byte[] fileContent = Files.readAllBytes(filePath);
 472                 String content = new String(fileContent);
 473                 return content;
 474         }
 475
 476         protected static File getTestZipFile(String elementName) throws IOException {
 477                 String sourceDir = config.getImportResourceTestsConfigDir();
 478
 479                 java.nio.file.Path filePath = FileSystems.getDefault().getPath(sourceDir + File.separator + elementName, "normative-types-new-" + elementName + ".zip");
 480                 return filePath.toFile();
 481         }
 482
 483         protected static Either<String, Boolean> getResource(String name, String version) throws IOException {
 484                 RestResponse resource = ResourceRestUtils.getResourceByNameAndVersion(UserRoleEnum.DESIGNER.getUserId(), name, version);
 485                 if (resource.getErrorCode() == ImportRestUtils.STATUS_CODE_GET_SUCCESS) {
 486                         return Either.left(resource.getResponse());
 487                         // return Either.right(true);
 488
 489                 }
 490                 return Either.right(false);
 491         }
 492
 493         @Test
 494         public void testImportWithRequirmentsAndCapabilities() throws IOException {
 495                 String fileName = FILE_NAME_MY_COMPUTE;
 496                 RestResponse response = ImportRestUtils.importNormativeResourceByName(RESOURCE_NAME_MY_COMPUTE, UserRoleEnum.ADMIN);
 497                 Integer statusCode = response.getErrorCode();
 498                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 499                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 500                 validateMyComputeResource(uid, fileName, "1.0", "CERTIFIED");
 501         }
 502
 503         @Test
 504         public void testImportWithUpdateNormativeType() throws IOException {
 505                 String fileName = FILE_NAME_MY_COMPUTE;
 506                 RestResponse response = ImportRestUtils.importNormativeResourceByName(RESOURCE_NAME_MY_COMPUTE, UserRoleEnum.ADMIN);
 507                 Integer statusCode = response.getErrorCode();
 508                 assertTrue(String.format("Expected code %s and got code %s",ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS,statusCode),statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 509                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 510                 validateMyComputeResource(uid, fileName, "1.0", "CERTIFIED");
 511
 512                 // update
 513                 response = ImportRestUtils.importNormativeResourceByName(RESOURCE_NAME_MY_COMPUTE, UserRoleEnum.ADMIN);
 514                 statusCode = response.getErrorCode();
 515                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_UPDATE_SUCCESS);
 516                 uid = ResponseParser.getUniqueIdFromResponse(response);
 517                 validateMyComputeResource(uid, fileName, "2.0", "CERTIFIED");
 518
 519         }
 520
 521         @Test
 522         public void testImportWithInvalidDefaultValue() throws IOException {
 523                 RestResponse response = ImportRestUtils.importNewResourceByName("portInvalidDefaultValue", UserRoleEnum.DESIGNER);
 524                 assertTrue(response.getErrorCode() == HttpStatus.SC_BAD_REQUEST);
 525         }
 526
 527         @Test
 528         public void testImportUserResource() throws IOException {
 529                 String fileName = FILE_NAME_USER_COMPUTE;
 530                 RestResponse response = ImportRestUtils.importNewResourceByName(RESOURCE_NAME_USER_COMPUTE, UserRoleEnum.DESIGNER);
 531                 Integer statusCode = response.getErrorCode();
 532                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 533                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 534                 validateMyComputeResource(uid, fileName, "0.1", "NOT_CERTIFIED_CHECKOUT");
 535
 536         }
 537
 538         @Test
 539         public void testImportAndUpdateUserResource() throws IOException {
 540                 String fileName = FILE_NAME_USER_COMPUTE;
 541                 RestResponse response = ImportRestUtils.importNewResourceByName(RESOURCE_NAME_USER_COMPUTE, UserRoleEnum.DESIGNER);
 542                 Integer statusCode = response.getErrorCode();
 543                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 544                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 545                 validateMyComputeResource(uid, fileName, "0.1", "NOT_CERTIFIED_CHECKOUT");
 546                 response = ImportRestUtils.importNewResourceByName(RESOURCE_NAME_UPDATE_COMPUTE, UserRoleEnum.DESIGNER);
 547                 statusCode = response.getErrorCode();
 548                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_UPDATE_SUCCESS);
 549                 uid = ResponseParser.getUniqueIdFromResponse(response);
 550                 validateMyComputeResourceAfterUpdate(uid, fileName, "0.1", "NOT_CERTIFIED_CHECKOUT");
 551
 552         }
 553
 554         @Test
 555         public void testImportAndUpdateChangesUserResource() throws IOException {
 556                 String fileName = FILE_NAME_USER_COMPUTE;
 557                 RestResponse response = ImportRestUtils.importNewResourceByName(RESOURCE_NAME_USER_COMPUTE, UserRoleEnum.DESIGNER);
 558                 Integer statusCode = response.getErrorCode();
 559                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 560                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 561                 validateMyComputeResource(uid, fileName, "0.1", "NOT_CERTIFIED_CHECKOUT");
 562                 // Either<String, Boolean> resource = getResource(fileName, "0.1");
 563                 // assertTrue(resource.isLeft());
 564
 565                 response = ImportRestUtils.importNewResourceByName(RESOURCE_NAME_UPDATE_COMPUTE, UserRoleEnum.DESIGNER);
 566                 statusCode = response.getErrorCode();
 567                 assertTrue(statusCode == ImportRestUtils.STATUS_CODE_UPDATE_SUCCESS);
 568                 validateMyComputeResourceAfterUpdate(uid, fileName, "0.1", "NOT_CERTIFIED_CHECKOUT");
 569
 570         }
 571
 572         @Test
 573         public void testImportCheckoutAndUpdateUserResource() throws IOException {
 574                 String fileName = FILE_NAME_USER_COMPUTE;
 575                 RestResponse response = ImportRestUtils.importNormativeResourceByName(RESOURCE_NAME_USER_COMPUTE, UserRoleEnum.ADMIN);
 576                 Integer statusCode = response.getErrorCode();
 577                 assertTrue(String.format("Expected code %s and got code %s",ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS,statusCode),statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 578                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 579                 validateMyComputeResource(uid, fileName, "1.0", "CERTIFIED");
 580
 581                 response = ImportRestUtils.importNewResourceByName(RESOURCE_NAME_USER_COMPUTE, UserRoleEnum.DESIGNER);
 582                 statusCode = response.getErrorCode();
 583                 assertEquals("check response code after update resource", ImportRestUtils.STATUS_CODE_UPDATE_SUCCESS, statusCode.intValue());
 584                 uid = ResponseParser.getUniqueIdFromResponse(response);
 585                 validateMyComputeResource(uid, fileName, "1.1", "NOT_CERTIFIED_CHECKOUT");
 586
 587         }
 588
 589         @Test
 590         public void importNormativeTypesTesterUserRole() throws Exception {
 591                 Integer statusCode = ImportRestUtils.importNormativeResourceByName(RESOURCE_NAME_MY_COMPUTE, UserRoleEnum.TESTER).getErrorCode();
 592                 assertTrue(statusCode == ImportRestUtils.RESTRICTED_OPERATION);
 593         }
 594
 595         @Test
 596         public void importNormativeTypesDesignerUserRole() throws Exception {
 597                 Integer statusCode = ImportRestUtils.importNormativeResourceByName(RESOURCE_NAME_MY_COMPUTE, UserRoleEnum.DESIGNER).getErrorCode();
 598                 assertTrue(statusCode == 409);
 599         }
 600
 601         @Test
 602         public void testImportVFCDerivedFromGeneric() throws IOException {
 603
 604                 RestResponse response = ImportRestUtils.importNewResourceByName(FILE_NAME_USER_VFC, UserRoleEnum.ADMIN);
 605                 Integer statusCode = response.getErrorCode();
 606                 assertTrue(String.format("Expected code %s and got code %s",ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS,statusCode),statusCode == ImportRestUtils.STATUS_CODE_IMPORT_SUCCESS);
 607                 String uid = ResponseParser.getUniqueIdFromResponse(response);
 608                 response = ResourceRestUtils.getResource(uid);
 609                 Resource VFC = ResponseParser.convertResourceResponseToJavaObject(response.getResponse());
 610                 List<PropertyDefinition> props = VFC.getProperties();
 611                 for (PropertyDefinition prop : props) {
 612                         assertTrue(null != prop.getOwnerId() && !uid.equals(prop.getOwnerId()));
 613
 614                 }
 615
 616         }
 617
 618 }