catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.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  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.components;
  24
  25 import static org.junit.jupiter.api.Assertions.assertEquals;
  26 import static org.junit.jupiter.api.Assertions.assertFalse;
  27 import static org.junit.jupiter.api.Assertions.assertNotNull;
  28 import static org.junit.jupiter.api.Assertions.assertNull;
  29 import static org.junit.jupiter.api.Assertions.assertSame;
  30 import static org.junit.jupiter.api.Assertions.assertThrows;
  31 import static org.junit.jupiter.api.Assertions.assertTrue;
  32 import static org.mockito.ArgumentMatchers.any;
  33 import static org.mockito.ArgumentMatchers.anyMap;
  34 import static org.mockito.ArgumentMatchers.anyString;
  35 import static org.mockito.ArgumentMatchers.eq;
  36 import static org.mockito.Mockito.anyBoolean;
  37 import static org.mockito.Mockito.mock;
  38 import static org.mockito.Mockito.times;
  39 import static org.mockito.Mockito.verify;
  40 import static org.mockito.Mockito.when;
  41
  42 import fj.data.Either;
  43 import java.io.IOException;
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.Collections;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50 import org.apache.commons.lang3.tuple.ImmutablePair;
  51 import org.junit.jupiter.api.BeforeAll;
  52 import org.junit.jupiter.api.BeforeEach;
  53 import org.junit.jupiter.api.Test;
  54 import org.mockito.stubbing.Answer;
  55 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  56 import org.openecomp.sdc.be.components.impl.ImportUtils;
  57 import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
  58 import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
  59 import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
  60 import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
  61 import org.openecomp.sdc.be.components.impl.ResourceImportManager;
  62 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  63 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
  64 import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
  65 import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
  66 import org.openecomp.sdc.be.config.Configuration;
  67 import org.openecomp.sdc.be.config.ConfigurationManager;
  68 import org.openecomp.sdc.be.dao.api.ActionStatus;
  69 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
  70 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  71 import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
  72 import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
  73 import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
  74 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  75 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  76 import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
  77 import org.openecomp.sdc.be.impl.ComponentsUtils;
  78 import org.openecomp.sdc.be.model.CapabilityDefinition;
  79 import org.openecomp.sdc.be.model.Component;
  80 import org.openecomp.sdc.be.model.InterfaceDefinition;
  81 import org.openecomp.sdc.be.model.NodeTypeMetadata;
  82 import org.openecomp.sdc.be.model.NodeTypesMetadataList;
  83 import org.openecomp.sdc.be.model.PropertyConstraint;
  84 import org.openecomp.sdc.be.model.PropertyDefinition;
  85 import org.openecomp.sdc.be.model.RequirementDefinition;
  86 import org.openecomp.sdc.be.model.Resource;
  87 import org.openecomp.sdc.be.model.UploadResourceInfo;
  88 import org.openecomp.sdc.be.model.User;
  89 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  90 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  91 import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
  92 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
  93 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  94 import org.openecomp.sdc.be.user.UserBusinessLogic;
  95 import org.openecomp.sdc.be.utils.TypeUtils;
  96 import org.openecomp.sdc.common.api.ConfigurationSource;
  97 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  98 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  99 import org.openecomp.sdc.exception.PolicyException;
 100 import org.openecomp.sdc.exception.ResponseFormat;
 101
 102 class ResourceImportManagerTest {
 103
 104     private ResourceImportManager importManager;
 105
 106     private final AuditingManager auditingManager = mock(AuditingManager.class);
 107     private final ResponseFormatManager responseFormatManager = mock(ResponseFormatManager.class);
 108     private final ResourceBusinessLogic resourceBusinessLogic = mock(ResourceBusinessLogic.class);
 109     private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = mock(InterfaceOperationBusinessLogic.class);
 110     private final InterfaceDefinitionHandler interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
 111     private final JanusGraphDao janusGraphDao = mock(JanusGraphDao.class);
 112     private final UserBusinessLogic userAdmin = mock(UserBusinessLogic.class);
 113     private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
 114     private final ComponentsUtils componentsUtils = mock(ComponentsUtils.class);
 115     private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
 116     private UploadResourceInfo resourceMD;
 117     private User user;
 118
 119     @BeforeAll
 120     public static void beforeClass() {
 121         String appConfigDir = "src/test/resources/config/catalog-be";
 122         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
 123         final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
 124
 125         Configuration configuration = new Configuration();
 126         configuration.setJanusGraphInMemoryGraph(true);
 127         configurationManager.setConfiguration(configuration);
 128     }
 129
 130     @BeforeEach
 131     public void beforeTest() {
 132         importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler, janusGraphDao);
 133         importManager.setAuditingManager(auditingManager);
 134         when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any())).thenReturn(Either.left(null));
 135         when(toscaOperationFacade.getLatestByToscaResourceNameAndModel(anyString(), any())).thenReturn(Either.left(null));
 136         importManager.setResponseFormatManager(responseFormatManager);
 137         importManager.setResourceBusinessLogic(resourceBusinessLogic);
 138         importManager.setToscaOperationFacade(toscaOperationFacade);
 139         Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
 140         when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
 141             any(JsonParseFlagEnum.class), any())).thenReturn(notFound);
 142         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
 143             .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 144         resourceMD = createDummyResourceMD();
 145         user = new User();
 146     }
 147
 148     @Test
 149     void testBasicResourceCreation() throws IOException {
 150         user.setUserId(resourceMD.getContactId());
 151         user.setRole("ADMIN");
 152         user.setFirstName("Jhon");
 153         user.setLastName("Doh");
 154         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 155
 156         setResourceBusinessLogicMock();
 157
 158         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
 159
 160         ImmutablePair<Resource, ActionStatus> createResource =
 161             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 162         Resource resource = createResource.left;
 163
 164         testSetConstantMetaData(resource);
 165         testSetMetaDataFromJson(resource, resourceMD);
 166
 167         testSetDerivedFrom(resource);
 168         testSetProperties(resource);
 169
 170         verify(resourceBusinessLogic).propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true),
 171             eq(false));
 172     }
 173
 174     @Test
 175     void testReimportVfcToExistedResource() throws IOException {
 176         user.setUserId(resourceMD.getContactId());
 177         user.setRole("ADMIN");
 178         user.setFirstName("John");
 179         user.setLastName("Doe");
 180         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 181
 182         setResourceBusinessLogicMock();
 183
 184         final String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
 185
 186         ImmutablePair<Resource, ActionStatus> createResource =
 187             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 188         assertNotNull(createResource);
 189         Resource resource = createResource.left;
 190         assertNotNull(resource);
 191
 192         final GraphVertex graphVertex_1 = new GraphVertex();
 193         graphVertex_1.setUniqueId("1-2-3-4-5-6-7");
 194         graphVertex_1.addMetadataProperty(GraphPropertyEnum.VERSION, "1.1");
 195         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
 196             .thenReturn(Either.left(Arrays.asList(graphVertex_1)));
 197         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
 198         createResource = reimportVfc(resource, jsonContent);
 199         assertNotNull(createResource);
 200         resource = createResource.left;
 201         assertNotNull(resource);
 202         testPropertiesAfterReimport(resource);
 203
 204         final GraphVertex graphVertex_2 = new GraphVertex();
 205         graphVertex_2.setUniqueId("11-22-33-44-55-66-77");
 206         graphVertex_2.addMetadataProperty(GraphPropertyEnum.VERSION, "2.2");
 207         when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
 208             .thenReturn(Either.left(Arrays.asList(graphVertex_1, graphVertex_2)));
 209         when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
 210         createResource = reimportVfc(resource, jsonContent);
 211         assertNotNull(createResource);
 212         resource = createResource.left;
 213         assertNotNull(resource);
 214         testPropertiesAfterReimport(resource);
 215
 216         verify(resourceBusinessLogic, times(3))
 217             .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
 218     }
 219
 220     @Test
 221     void importAllNormativeResourceSuccessTest() {
 222         final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
 223         var nodeTypeMetadata1 = new NodeTypeMetadata();
 224         nodeTypeMetadata1.setToscaName("my.tosca.Type");
 225         nodeTypeMetadata1.setName("Type");
 226         nodeMetadataList.add(nodeTypeMetadata1);
 227         var nodeTypeMetadata2 = new NodeTypeMetadata();
 228         nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
 229         nodeMetadataList.add(nodeTypeMetadata2);
 230         var nodeTypesMetadataList = new NodeTypesMetadataList();
 231         nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
 232         var yaml = "node_types:\n"
 233             + "  my.tosca.Type:\n"
 234             + "    description: a description";
 235
 236         when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null));
 237         when(resourceBusinessLogic
 238             .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
 239             .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
 240
 241         importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false);
 242         verify(janusGraphDao).commit();
 243     }
 244
 245     @Test
 246     void importAllNormativeResourceTest_invalidYaml() {
 247         var invalidYaml = "node_types: my.tosca.Type:";
 248
 249         final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
 250             () -> importManager.importAllNormativeResource(invalidYaml, new NodeTypesMetadataList(), new User(), false, false));
 251         assertEquals(ActionStatus.INVALID_NODE_TYPES_YAML, actualException.getActionStatus());
 252     }
 253
 254     @Test
 255     void importAllNormativeResourceTest_exceptionDuringImportShouldTriggerRollback() {
 256         when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(mock(ResponseFormat.class));
 257         when(toscaOperationFacade.getLatestByName(any(), any())).thenThrow(new RuntimeException());
 258
 259         final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
 260         var nodeTypeMetadata1 = new NodeTypeMetadata();
 261         nodeTypeMetadata1.setToscaName("my.tosca.Type");
 262         nodeMetadataList.add(nodeTypeMetadata1);
 263         var nodeTypeMetadata2 = new NodeTypeMetadata();
 264         nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
 265         nodeMetadataList.add(nodeTypeMetadata2);
 266         var nodeTypesMetadataList = new NodeTypesMetadataList();
 267         nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
 268         var yaml = "node_types:\n"
 269             + "  my.tosca.Type:\n"
 270             + "    description: a description";
 271
 272         assertThrows(ComponentException.class,
 273             () -> importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false));
 274         verify(janusGraphDao).rollback();
 275     }
 276
 277     @Test
 278     void testResourceCreationFailed() {
 279         user.setUserId(resourceMD.getContactId());
 280         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 281         ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
 282
 283         when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
 284         setResourceBusinessLogicMock();
 285
 286         String jsonContent = "this is an invalid yml!";
 287         ComponentException errorInfoFromTest = null;
 288         try {
 289             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 290         } catch (ComponentException e) {
 291             errorInfoFromTest = e;
 292         }
 293         assertNotNull(errorInfoFromTest);
 294         assertEquals(ActionStatus.GENERAL_ERROR, errorInfoFromTest.getActionStatus());
 295
 296         verify(resourceBusinessLogic, times(0))
 297             .createOrUpdateResourceByImport(any(Resource.class), eq(user), eq(true), eq(false), eq(true), eq(null), eq(null), eq(false));
 298         verify(resourceBusinessLogic, times(0))
 299             .propagateStateToCertified(eq(user), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
 300     }
 301
 302     @Test
 303     void testResourceCreationWithCapabilities() throws IOException {
 304         user.setUserId(resourceMD.getContactId());
 305         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 306
 307         setResourceBusinessLogicMock();
 308
 309         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
 310
 311         ImmutablePair<Resource, ActionStatus> createResource =
 312             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 313         Resource resource = createResource.left;
 314         testSetCapabilities(resource);
 315
 316         verify(resourceBusinessLogic)
 317             .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
 318         verify(resourceBusinessLogic).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
 319
 320     }
 321
 322     @Test
 323     void testResourceCreationWithRequirements() throws IOException {
 324         user.setUserId(resourceMD.getContactId());
 325         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 326
 327         setResourceBusinessLogicMock();
 328
 329         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
 330
 331         ImmutablePair<Resource, ActionStatus> createResource =
 332             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 333         testSetRequirements(createResource.left);
 334
 335     }
 336
 337     @Test
 338     void testResourceCreationWithInterfaceImplementation() throws IOException {
 339         user.setUserId(resourceMD.getContactId());
 340         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 341
 342         setResourceBusinessLogicMock();
 343
 344         String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
 345
 346         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 347         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 348         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 349         Map<String, OperationDataDefinition> operations = new HashMap<>();
 350         operations.put("configure", new OperationDataDefinition());
 351         interfaceDefinition.setOperations(operations);
 352         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 353         when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
 354
 355         final ImmutablePair<Resource, ActionStatus> createResource =
 356             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 357         assertSetInterfaceImplementation(createResource.left);
 358     }
 359
 360     @Test
 361     void testResourceCreationWithInterfaceImplementation_UnknownInterface() throws IOException {
 362         user.setUserId(resourceMD.getContactId());
 363         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 364
 365         setResourceBusinessLogicMock();
 366
 367         String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-unknown-interface-impl.yml");
 368
 369         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 370         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 371         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 372         Map<String, OperationDataDefinition> operations = new HashMap<>();
 373         operations.put("configure", new OperationDataDefinition());
 374         interfaceDefinition.setOperations(operations);
 375         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 376         when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
 377
 378         ImmutablePair<Resource, ActionStatus> createResource =
 379             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 380         assertNull(createResource.left.getInterfaces());
 381     }
 382
 383     @Test
 384     void testResourceCreationWitInterfaceImplementation_UnknownOperation() throws IOException {
 385         user.setUserId(resourceMD.getContactId());
 386         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 387
 388         setResourceBusinessLogicMock();
 389
 390         String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl-unknown-operation.yml");
 391
 392         Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
 393         final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 394         interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
 395         Map<String, OperationDataDefinition> operations = new HashMap<>();
 396         operations.put("configure", new OperationDataDefinition());
 397         interfaceDefinition.setOperations(operations);
 398         interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
 399         when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
 400
 401         ImmutablePair<Resource, ActionStatus> createResource =
 402             importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 403         assertNull(createResource.left.getInterfaces());
 404     }
 405
 406     @Test
 407     void testResourceCreationFailedVendorReleaseAlreadyExists() throws IOException {
 408         user.setUserId(resourceMD.getContactId());
 409         user.setRole("ADMIN");
 410         user.setFirstName("Jhon");
 411         user.setLastName("Doh");
 412         when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
 413
 414         setResourceBusinessLogicMock();
 415         final Either<Component, StorageOperationStatus> foundResourceEither = Either.left(mock(Resource.class));
 416         when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
 417             any(JsonParseFlagEnum.class), any())).thenReturn(foundResourceEither);
 418         when(toscaOperationFacade.isNodeAssociatedToModel(eq(null), any(Resource.class))).thenReturn(true);
 419
 420         String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
 421
 422         var actualException = assertThrows(ByActionStatusComponentException.class,
 423             () -> importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false));
 424         assertEquals(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, actualException.getActionStatus());
 425     }
 426
 427     private void setResourceBusinessLogicMock() {
 428         when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
 429         when(resourceBusinessLogic.createOrUpdateResourceByImport(any(Resource.class), any(User.class), anyBoolean(), anyBoolean(), anyBoolean(),
 430             eq(null), eq(null), eq(false)))
 431             .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
 432                 Object[] args = invocation.getArguments();
 433                 return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
 434
 435             });
 436         when(
 437             resourceBusinessLogic.propagateStateToCertified(any(User.class), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false),
 438                 eq(true), eq(false)))
 439             .thenAnswer((Answer<Resource>) invocation -> {
 440                 Object[] args = invocation.getArguments();
 441                 return (Resource) args[1];
 442
 443             });
 444         when(resourceBusinessLogic.createResourceByDao(
 445             any(Resource.class), any(User.class), any(AuditingActionEnum.class), anyBoolean(), anyBoolean())).thenAnswer(
 446             (Answer<Either<Resource, ResponseFormat>>) invocation -> {
 447                 Object[] args = invocation.getArguments();
 448                 return Either.left((Resource) args[0]);
 449
 450             });
 451         when(resourceBusinessLogic.validateResourceBeforeCreate(
 452             any(Resource.class), any(User.class), any(AuditingActionEnum.class), eq(false), eq(null))).thenAnswer(
 453             (Answer<Either<Resource, ResponseFormat>>) invocation -> {
 454                 Object[] args = invocation.getArguments();
 455                 return Either.left((Resource) args[0]);
 456
 457             });
 458
 459         when(resourceBusinessLogic.validatePropertiesDefaultValues(any(Resource.class))).thenReturn(true);
 460     }
 461
 462     private ResponseFormat createGeneralErrorInfo() {
 463         ResponseFormat responseFormat = new ResponseFormat(500);
 464         responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
 465         return responseFormat;
 466     }
 467
 468     private UploadResourceInfo createDummyResourceMD() {
 469         UploadResourceInfo resourceMD = new UploadResourceInfo();
 470         resourceMD.setName("tosca.nodes.BlockStorage");
 471         resourceMD.setPayloadName("payLoad");
 472         resourceMD.addSubCategory("Generic", "Infrastructure");
 473         resourceMD.setContactId("ya107f");
 474         resourceMD.setResourceIconPath("defaulticon");
 475         resourceMD.setTags(Collections.singletonList("BlockStorage"));
 476         resourceMD.setDescription(
 477             "Represents a server-local block storage device (i.e., not shared) offering evenly sized blocks of data from which raw storage volumes can be created.");
 478         resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
 479         resourceMD.setNormative(true);
 480         return resourceMD;
 481     }
 482
 483     private void testSetProperties(Resource resource) {
 484         List<PropertyDefinition> propertiesList = resource.getProperties();
 485
 486         Map<String, PropertyDefinition> properties = new HashMap<>();
 487         for (PropertyDefinition propertyDefinition : propertiesList) {
 488             properties.put(propertyDefinition.getName(), propertyDefinition);
 489         }
 490
 491         assertEquals(3, properties.size());
 492         assertTrue(properties.containsKey("size"));
 493         PropertyDefinition propertyDefinition = properties.get("size");
 494         assertEquals("scalar-unit.size", propertyDefinition.getType());
 495         assertEquals(1, propertyDefinition.getConstraints().size());
 496         PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
 497         assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
 498
 499         assertTrue(properties.containsKey("volume_id"));
 500         propertyDefinition = properties.get("volume_id");
 501         assertEquals("string", propertyDefinition.getType());
 502         assertFalse(propertyDefinition.isRequired());
 503
 504         assertTrue(properties.containsKey("snapshot_id"));
 505         propertyDefinition = properties.get("snapshot_id");
 506         assertEquals("string", propertyDefinition.getType());
 507         assertFalse(propertyDefinition.isRequired());
 508
 509     }
 510
 511     private ImmutablePair<Resource, ActionStatus> reimportVfc(Resource resource, String jsonContent) {
 512         List<PropertyDefinition> propertiesList = resource.getProperties();
 513         PropertyDefinition propertyDefinition = new PropertyDefinition();
 514         propertyDefinition.setName("oneMore");
 515         propertyDefinition.setUserCreated(true);
 516         propertyDefinition.setType("boolean");
 517         propertiesList.add(propertyDefinition);
 518         resource.setProperties(propertiesList);
 519         return importManager.importNormativeResource(jsonContent, resourceMD, user, true, true, false);
 520
 521     }
 522
 523     private void testPropertiesAfterReimport(Resource resource) {
 524         List<PropertyDefinition> propertiesList = resource.getProperties();
 525
 526         Map<String, PropertyDefinition> properties = new HashMap<>();
 527         for (PropertyDefinition propertyDefinition : propertiesList) {
 528             properties.put(propertyDefinition.getName(), propertyDefinition);
 529         }
 530
 531         assertEquals(4, properties.size());
 532
 533         assertTrue(properties.containsKey("size"));
 534         PropertyDefinition propertyDefinition = properties.get("size");
 535         assertEquals("scalar-unit.size", propertyDefinition.getType());
 536         assertEquals(1, propertyDefinition.getConstraints().size());
 537         PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
 538         assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
 539
 540         assertTrue(properties.containsKey("volume_id"));
 541         propertyDefinition = properties.get("volume_id");
 542         assertEquals("string", propertyDefinition.getType());
 543         assertFalse(propertyDefinition.isRequired());
 544         assertFalse(propertyDefinition.isUserCreated());
 545
 546         assertTrue(properties.containsKey("snapshot_id"));
 547         propertyDefinition = properties.get("snapshot_id");
 548         assertEquals("string", propertyDefinition.getType());
 549         assertFalse(propertyDefinition.isRequired());
 550         assertFalse(propertyDefinition.isUserCreated());
 551
 552         assertTrue(properties.containsKey("oneMore"));
 553         propertyDefinition = properties.get("oneMore");
 554         assertEquals("boolean", propertyDefinition.getType());
 555         assertFalse(propertyDefinition.isRequired());
 556         assertTrue(propertyDefinition.isUserCreated());
 557     }
 558
 559     private void testSetCapabilities(Resource resource) {
 560         Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
 561         assertEquals(3, capabilities.size());
 562         assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
 563         List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
 564         CapabilityDefinition capability = capabilityList.get(0);
 565         assertEquals("tosca.capabilities.Endpoint", capability.getType());
 566         assertEquals("data_endpoint", capability.getName());
 567
 568         assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
 569         capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
 570         capability = capabilityList.get(0);
 571         assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
 572         assertEquals("admin_endpoint", capability.getName());
 573
 574         assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
 575         capabilityList = capabilities.get("tosca.capabilities.Container");
 576         capability = capabilityList.get(0);
 577         assertEquals("tosca.capabilities.Container", capability.getType());
 578         assertEquals("host", capability.getName());
 579
 580         List<String> validSourceTypes = capability.getValidSourceTypes();
 581         assertEquals(1, validSourceTypes.size());
 582         assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
 583
 584     }
 585
 586     private void testSetRequirements(Resource resource) {
 587         Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
 588         assertEquals(2, requirements.size());
 589
 590         assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
 591         List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
 592         RequirementDefinition requirement = requirementList.get(0);
 593         assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
 594         assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
 595         assertEquals("link", requirement.getName());
 596
 597         assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
 598         requirementList = requirements.get("tosca.capabilities.network.Bindable");
 599         requirement = requirementList.get(0);
 600         assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
 601         assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
 602         assertEquals("binding", requirement.getName());
 603
 604     }
 605
 606     private void assertSetInterfaceImplementation(final Resource resource) {
 607         final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
 608         assertNotNull(interfaces);
 609         assertEquals(1, interfaces.size());
 610         final InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
 611         assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
 612         Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
 613         operations.values().forEach(operationDataDefinition ->
 614             assertTrue(operations.containsKey(operationDataDefinition.getName())));
 615     }
 616
 617     private void testSetDerivedFrom(Resource resource) {
 618         assertEquals(1, resource.getDerivedFrom().size());
 619         assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
 620
 621     }
 622
 623     private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
 624         assertEquals(resource.getDescription(), resourceMD.getDescription());
 625         assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
 626         assertEquals(resource.getName(), resourceMD.getName());
 627         assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
 628         assertEquals(resource.getContactId(), resourceMD.getContactId());
 629         assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
 630         assertEquals(resourceMD.getTags().size(), resource.getTags().size());
 631         for (String tag : resource.getTags()) {
 632             assertTrue(resourceMD.getTags().contains(tag));
 633         }
 634         assertEquals(resourceMD.isNormative(), resource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
 635     }
 636
 637     private void testSetConstantMetaData(Resource resource) {
 638         assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
 639         assertSame(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE, resource.getLifecycleState());
 640         assertEquals(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION, resource.isHighestVersion());
 641         assertEquals(ImportUtils.Constants.VENDOR_NAME, resource.getVendorName());
 642         assertEquals(ImportUtils.Constants.VENDOR_RELEASE, resource.getVendorRelease());
 643     }
 644
 645 }