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