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