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