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