* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* ============LICENSE_END=========================================================
+ * Modifications copyright (c) 2019 Nokia
+ * ================================================================================
*/
package org.openecomp.sdc.be.components;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import fj.data.Either;
+import java.io.File;
import java.io.IOException;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
import java.util.Arrays;
-import java.util.EnumMap;
+import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-
+import java.util.Optional;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.tuple.ImmutablePair;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
import org.mockito.stubbing.Answer;
-import org.openecomp.sdc.be.auditing.api.IAuditingManager;
+import org.openecomp.sdc.be.auditing.impl.AuditingManager;
+import org.openecomp.sdc.be.components.csar.ServiceCsarInfo;
import org.openecomp.sdc.be.components.impl.ImportUtils;
import org.openecomp.sdc.be.components.impl.ImportUtilsTest;
+import org.openecomp.sdc.be.components.impl.InterfaceDefinitionHandler;
+import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic;
import org.openecomp.sdc.be.components.impl.ResourceBusinessLogic;
import org.openecomp.sdc.be.components.impl.ResourceImportManager;
import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
+import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
+import org.openecomp.sdc.be.components.impl.exceptions.ComponentException;
import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction;
import org.openecomp.sdc.be.config.Configuration;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphDao;
+import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
+import org.openecomp.sdc.be.dao.jsongraph.GraphVertex;
+import org.openecomp.sdc.be.dao.jsongraph.types.JsonParseFlagEnum;
+import org.openecomp.sdc.be.dao.jsongraph.types.VertexTypeEnum;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.GraphPropertyEnum;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.NodeTypeDefinition;
+import org.openecomp.sdc.be.model.NodeTypeMetadata;
+import org.openecomp.sdc.be.model.NodeTypesMetadataList;
import org.openecomp.sdc.be.model.PropertyConstraint;
import org.openecomp.sdc.be.model.PropertyDefinition;
import org.openecomp.sdc.be.model.RequirementDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.UploadResourceInfo;
import org.openecomp.sdc.be.model.User;
-import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
-import org.openecomp.sdc.be.model.operations.impl.ResourceOperation;
+import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.model.operations.impl.CapabilityTypeOperation;
+import org.openecomp.sdc.be.model.operations.impl.ModelOperation;
import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
import org.openecomp.sdc.be.user.UserBusinessLogic;
+import org.openecomp.sdc.be.utils.TypeUtils;
import org.openecomp.sdc.common.api.ConfigurationSource;
import org.openecomp.sdc.common.impl.ExternalConfiguration;
import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.openecomp.sdc.common.zip.ZipUtils;
+import org.openecomp.sdc.common.zip.exception.ZipException;
import org.openecomp.sdc.exception.PolicyException;
import org.openecomp.sdc.exception.ResponseFormat;
-import org.slf4j.Logger;
-
-import fj.data.Either;
-
-public class ResourceImportManagerTest {
-
- private static ConfigurationManager configurationManager;
- static ResourceImportManager importManager;
- static IAuditingManager auditingManager = Mockito.mock(IAuditingManager.class);
- static ResponseFormatManager responseFormatManager = Mockito.mock(ResponseFormatManager.class);
- static ResourceBusinessLogic resourceBusinessLogic = Mockito.mock(ResourceBusinessLogic.class);
- static UserBusinessLogic userAdmin = Mockito.mock(UserBusinessLogic.class);
- static ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class);
- static Logger log = Mockito.spy(Logger.class);
-
- @BeforeClass
- public static void beforeClass() throws IOException {
- importManager = new ResourceImportManager();
- importManager.setAuditingManager(auditingManager);
- when(toscaOperationFacade.getLatestByToscaResourceName(Mockito.anyString())).thenReturn(Either.left(null));
- importManager.setResponseFormatManager(responseFormatManager);
- importManager.setResourceBusinessLogic(resourceBusinessLogic);
- importManager.setToscaOperationFacade(toscaOperationFacade);
- ResourceImportManager.setLog(log);
-
- String appConfigDir = "src/test/resources/config/catalog-be";
- ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
- configurationManager = new ConfigurationManager(configurationSource);
-
- Configuration configuration = new Configuration();
- configuration.setTitanInMemoryGraph(true);
- configurationManager.setConfiguration(configuration);
- }
-
- @Before
- public void beforeTest() {
- Mockito.reset(auditingManager, responseFormatManager, resourceBusinessLogic, userAdmin, log);
- }
-
- @Test
- public void testBasicResourceCreation() throws IOException {
- UploadResourceInfo resourceMD = createDummyResourceMD();
-
- User user = new User();
- user.setUserId(resourceMD.getContactId());
- user.setRole("ADMIN");
- user.setFirstName("Jhon");
- user.setLastName("Doh");
- Either<User, ActionStatus> eitherUser = Either.left(user);
-
- when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherUser);
- setResourceBusinessLogicMock();
+class ResourceImportManagerTest {
+
+ private ResourceImportManager importManager;
+
+ private final AuditingManager auditingManager = mock(AuditingManager.class);
+ private final ResponseFormatManager responseFormatManager = mock(ResponseFormatManager.class);
+ private final ResourceBusinessLogic resourceBusinessLogic = mock(ResourceBusinessLogic.class);
+ private final InterfaceOperationBusinessLogic interfaceOperationBusinessLogic = mock(InterfaceOperationBusinessLogic.class);
+ private final InterfaceDefinitionHandler interfaceDefinitionHandler = new InterfaceDefinitionHandler(interfaceOperationBusinessLogic);
+ private final JanusGraphDao janusGraphDao = mock(JanusGraphDao.class);
+ private final UserBusinessLogic userAdmin = mock(UserBusinessLogic.class);
+ private final ToscaOperationFacade toscaOperationFacade = mock(ToscaOperationFacade.class);
+ private final ComponentsUtils componentsUtils = mock(ComponentsUtils.class);
+ private final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class);
+ private UploadResourceInfo resourceMD;
+ private User user;
+
+ @BeforeAll
+ public static void beforeClass() {
+ String appConfigDir = "src/test/resources/config/catalog-be";
+ ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
+ final ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
+
+ Configuration configuration = new Configuration();
+ configuration.setJanusGraphInMemoryGraph(true);
+ configurationManager.setConfiguration(configuration);
+ }
+
+ @BeforeEach
+ public void beforeTest() {
+ importManager = new ResourceImportManager(componentsUtils, capabilityTypeOperation, interfaceDefinitionHandler, janusGraphDao);
+ importManager.setAuditingManager(auditingManager);
+ when(toscaOperationFacade.getLatestByToscaResourceName(anyString(), any())).thenReturn(Either.left(null));
+ when(toscaOperationFacade.getLatestByToscaResourceNameAndModel(anyString(), any())).thenReturn(Either.left(null));
+ importManager.setResponseFormatManager(responseFormatManager);
+ importManager.setResourceBusinessLogic(resourceBusinessLogic);
+ importManager.setToscaOperationFacade(toscaOperationFacade);
+ Either<Component, StorageOperationStatus> notFound = Either.right(StorageOperationStatus.NOT_FOUND);
+ when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
+ any(JsonParseFlagEnum.class), any())).thenReturn(notFound);
+ when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
+ .thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
+ resourceMD = createDummyResourceMD();
+ user = new User();
+ }
+
+ @Test
+ void testBasicResourceCreation() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ user.setRole("ADMIN");
+ user.setFirstName("Jhon");
+ user.setLastName("Doh");
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ Resource resource = createResource.left;
+
+ testSetConstantMetaData(resource);
+ testSetMetaDataFromJson(resource, resourceMD);
+
+ testSetDerivedFrom(resource);
+ testSetProperties(resource);
+
+ verify(resourceBusinessLogic).propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true),
+ eq(false));
+ }
+
+ @Test
+ void testReimportVfcToExistedResource() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ user.setRole("ADMIN");
+ user.setFirstName("John");
+ user.setLastName("Doe");
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ final String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ assertNotNull(createResource);
+ Resource resource = createResource.left;
+ assertNotNull(resource);
+
+ final GraphVertex graphVertex_1 = new GraphVertex();
+ graphVertex_1.setUniqueId("1-2-3-4-5-6-7");
+ graphVertex_1.addMetadataProperty(GraphPropertyEnum.VERSION, "1.1");
+ when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
+ .thenReturn(Either.left(Arrays.asList(graphVertex_1)));
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
+ createResource = reimportVfc(resource, jsonContent);
+ assertNotNull(createResource);
+ resource = createResource.left;
+ assertNotNull(resource);
+ testPropertiesAfterReimport(resource);
+
+ final GraphVertex graphVertex_2 = new GraphVertex();
+ graphVertex_2.setUniqueId("11-22-33-44-55-66-77");
+ graphVertex_2.addMetadataProperty(GraphPropertyEnum.VERSION, "2.2");
+ when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
+ .thenReturn(Either.left(Arrays.asList(graphVertex_1, graphVertex_2)));
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
+ createResource = reimportVfc(resource, jsonContent);
+ assertNotNull(createResource);
+ resource = createResource.left;
+ assertNotNull(resource);
+ testPropertiesAfterReimport(resource);
+
+ verify(resourceBusinessLogic, times(3))
+ .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
+ }
+
+ @Test
+ void importAllNormativeResourceSuccessTest() {
+ final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
+ var nodeTypeMetadata1 = new NodeTypeMetadata();
+ nodeTypeMetadata1.setToscaName("my.tosca.Type");
+ nodeTypeMetadata1.setName("Type");
+ nodeMetadataList.add(nodeTypeMetadata1);
+ var nodeTypeMetadata2 = new NodeTypeMetadata();
+ nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
+ nodeMetadataList.add(nodeTypeMetadata2);
+ var nodeTypesMetadataList = new NodeTypesMetadataList();
+ nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
+ var yaml = "node_types:\n"
+ + " my.tosca.Type:\n"
+ + " description: a description";
+
+ when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null));
+ when(resourceBusinessLogic
+ .createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null), eq(null), eq(false)))
+ .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
+
+ importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false);
+ verify(janusGraphDao).commit();
+ }
+
+ @Test
+ void importAllNormativeResourceTest_invalidYaml() {
+ var invalidYaml = "node_types: my.tosca.Type:";
+
+ final ByActionStatusComponentException actualException = assertThrows(ByActionStatusComponentException.class,
+ () -> importManager.importAllNormativeResource(invalidYaml, new NodeTypesMetadataList(), new User(), false, false));
+ assertEquals(ActionStatus.INVALID_NODE_TYPES_YAML, actualException.getActionStatus());
+ }
+
+ @Test
+ void importAllNormativeResourceTest_exceptionDuringImportShouldTriggerRollback() {
+ when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(mock(ResponseFormat.class));
+ when(toscaOperationFacade.getLatestByName(any(), any())).thenThrow(new RuntimeException());
+
+ final List<NodeTypeMetadata> nodeMetadataList = new ArrayList<>();
+ var nodeTypeMetadata1 = new NodeTypeMetadata();
+ nodeTypeMetadata1.setToscaName("my.tosca.Type");
+ nodeMetadataList.add(nodeTypeMetadata1);
+ var nodeTypeMetadata2 = new NodeTypeMetadata();
+ nodeTypeMetadata2.setToscaName("my.tosca.not.in.the.Yaml");
+ nodeMetadataList.add(nodeTypeMetadata2);
+ var nodeTypesMetadataList = new NodeTypesMetadataList();
+ nodeTypesMetadataList.setNodeMetadataList(nodeMetadataList);
+ var yaml = "node_types:\n"
+ + " my.tosca.Type:\n"
+ + " description: a description";
+
+ assertThrows(ComponentException.class,
+ () -> importManager.importAllNormativeResource(yaml, nodeTypesMetadataList, user, false, false));
+ verify(janusGraphDao).rollback();
+ }
+
+ @Test
+ void testResourceCreationFailed() {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+ ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
+
+ when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
+ setResourceBusinessLogicMock();
+
+ String jsonContent = "this is an invalid yml!";
+ ComponentException errorInfoFromTest = null;
+ try {
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ } catch (ComponentException e) {
+ errorInfoFromTest = e;
+ }
+ assertNotNull(errorInfoFromTest);
+ assertEquals(ActionStatus.GENERAL_ERROR, errorInfoFromTest.getActionStatus());
+
+ verify(resourceBusinessLogic, times(0))
+ .createOrUpdateResourceByImport(any(Resource.class), eq(user), eq(true), eq(false), eq(true), eq(null), eq(null), eq(false));
+ verify(resourceBusinessLogic, times(0))
+ .propagateStateToCertified(eq(user), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
+ }
+
+ @Test
+ void testResourceCreationWithCapabilities() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ Resource resource = createResource.left;
+ testSetCapabilities(resource);
+
+ verify(resourceBusinessLogic)
+ .propagateStateToCertified(eq(user), eq(resource), any(LifecycleChangeInfoWithAction.class), eq(false), eq(true), eq(false));
+ verify(resourceBusinessLogic).createOrUpdateResourceByImport(resource, user, true, false, true, null, null, false);
+
+ }
+
+ @Test
+ void testResourceCreationWithRequirements() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ testSetRequirements(createResource.left);
+
+ }
+
+ @Test
+ void testResourceCreationWithInterfaceImplementation() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
+
+ Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
+ final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
+ Map<String, OperationDataDefinition> operations = new HashMap<>();
+ operations.put("configure", new OperationDataDefinition());
+ interfaceDefinition.setOperations(operations);
+ interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
+ when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
+
+ final ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ assertSetInterfaceImplementation(createResource.left);
+ }
+
+ @Test
+ void testReimportVfcWithInterfaceImplementation() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl.yml");
+
+ Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
+ final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
+ Map<String, OperationDataDefinition> operations = new HashMap<>();
+ operations.put("configure", new OperationDataDefinition());
+ interfaceDefinition.setOperations(operations);
+ interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
+ when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ assertNotNull(createResource);
+ Resource resource = createResource.getLeft();
+ assertNotNull(resource);
+ assertSetInterfaceImplementation(resource);
+
+ final GraphVertex graphVertex = new GraphVertex();
+ graphVertex.setUniqueId("1-2-3-4-5-6-7");
+ when(janusGraphDao.getByCriteria(eq(VertexTypeEnum.NODE_TYPE), anyMap(), anyMap(), eq(JsonParseFlagEnum.ParseAll), any(), anyBoolean()))
+ .thenReturn(Either.left(Arrays.asList(graphVertex)));
+ when(toscaOperationFacade.getToscaElement(anyString())).thenReturn(Either.left(resource));
+ createResource = reimportVfc(resource, jsonContent);
+ assertNotNull(createResource);
+ resource = createResource.getLeft();
+ assertNotNull(resource);
+ assertSetInterfaceImplementationAfterReimport(resource);
+ }
+
+ @Test
+ void testResourceCreationWithInterfaceImplementation_UnknownInterface() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-unknown-interface-impl.yml");
+
+ Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
+ final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
+ Map<String, OperationDataDefinition> operations = new HashMap<>();
+ operations.put("configure", new OperationDataDefinition());
+ interfaceDefinition.setOperations(operations);
+ interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
+ when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ assertNull(createResource.left.getInterfaces());
+ }
+
+ @Test
+ void testResourceCreationWitInterfaceImplementation_UnknownOperation() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+
+ String jsonContent = ImportUtilsTest.loadCustomTypeFileNameToJsonString("custom-types-node-type-with-interface-impl-unknown-operation.yml");
+
+ Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>();
+ final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard");
+ Map<String, OperationDataDefinition> operations = new HashMap<>();
+ operations.put("configure", new OperationDataDefinition());
+ interfaceDefinition.setOperations(operations);
+ interfaceTypes.put("tosca.interfaces.node.lifecycle.standard", interfaceDefinition);
+ when(interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(interfaceTypes));
+
+ ImmutablePair<Resource, ActionStatus> createResource =
+ importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+ assertNull(createResource.left.getInterfaces());
+ }
+
+ @Test
+ void testResourceCreationFailedVendorReleaseAlreadyExists() throws IOException {
+ user.setUserId(resourceMD.getContactId());
+ user.setRole("ADMIN");
+ user.setFirstName("Jhon");
+ user.setLastName("Doh");
+ when(userAdmin.getUser(anyString(), anyBoolean())).thenReturn(user);
+
+ setResourceBusinessLogicMock();
+ final Either<Component, StorageOperationStatus> foundResourceEither = Either.left(mock(Resource.class));
+ when(toscaOperationFacade.getComponentByNameAndVendorRelease(any(ComponentTypeEnum.class), anyString(), anyString(),
+ any(JsonParseFlagEnum.class), any())).thenReturn(foundResourceEither);
+ when(toscaOperationFacade.isNodeAssociatedToModel(eq(null), any(Resource.class))).thenReturn(true);
+
+ String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
+
+ var actualException = assertThrows(ByActionStatusComponentException.class,
+ () -> importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false));
+ assertEquals(ActionStatus.COMPONENT_WITH_VENDOR_RELEASE_ALREADY_EXISTS, actualException.getActionStatus());
+ }
+
+ @Test
+ void getAllResourcesYamlAndNodeTypesMetadataListTest() {
+ NodeTypesMetadataList nodeTypesMetadataList = new NodeTypesMetadataList();
+ List<NodeTypeMetadata> nodeTypeMetadataList = new ArrayList<>();
+ Map<String, Object> allTypesToCreate = new HashMap<>();
+ ServiceCsarInfo csarInfo = getCsarInfo();
+ List<NodeTypeDefinition> nodeTypesToCreate = csarInfo.getNodeTypesUsed();
+ nodeTypesToCreate.stream().forEach(nodeType -> {
+ allTypesToCreate.put(nodeType.getMappedNodeType().getKey(), nodeType.getMappedNodeType().getValue());
+ nodeTypeMetadataList.add(nodeType.getNodeTypeMetadata());
+ });
+ nodeTypesMetadataList.setNodeMetadataList(nodeTypeMetadataList);
+
+ when(toscaOperationFacade.getLatestByName(any(), any())).thenReturn(Either.left(null)).thenReturn(Either.left(null));
+ when(toscaOperationFacade.getLatestByToscaResourceName("org.openecomp.resource.VFC-root", "ETSI SOL001 v2.5.1"))
+ .thenReturn(Either.left(null));
+ when(toscaOperationFacade.getLatestByToscaResourceName("tosca.nodes.nfv.NS", ""))
+ .thenReturn(Either.left(createResourceNS()));
+ when(toscaOperationFacade.getLatestByToscaResourceName("org.openecomp.service.Etsiwithchild", ""))
+ .thenReturn(Either.right(null));
+ when(resourceBusinessLogic.createOrUpdateResourceByImport(any(Resource.class), any(User.class), eq(true), eq(true), eq(false), eq(null),
+ eq(null), eq(false))).thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK))
+ .thenReturn(new ImmutablePair<>(new Resource(), ActionStatus.OK));
+ when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(mock(ResponseFormat.class));
+
+ importManager.importAllNormativeResource(allTypesToCreate, nodeTypesMetadataList, null, user, "", false, false);
+ verify(janusGraphDao).commit();
+ }
+
+ private Resource createResourceNS() {
+ Resource ns = new Resource();
+ ns.setName("tosca.nodes.nfv.NS");
+ return ns;
+ }
+
+ private void setResourceBusinessLogicMock() {
+ when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
+ when(resourceBusinessLogic.createOrUpdateResourceByImport(any(Resource.class), any(User.class), anyBoolean(), anyBoolean(), anyBoolean(),
+ eq(null), eq(null), eq(false)))
+ .thenAnswer((Answer<ImmutablePair<Resource, ActionStatus>>) invocation -> {
+ Object[] args = invocation.getArguments();
+ return new ImmutablePair<>((Resource) args[0], ActionStatus.CREATED);
+
+ });
+ when(
+ resourceBusinessLogic.propagateStateToCertified(any(User.class), any(Resource.class), any(LifecycleChangeInfoWithAction.class), eq(false),
+ eq(true), eq(false)))
+ .thenAnswer((Answer<Resource>) invocation -> {
+ Object[] args = invocation.getArguments();
+ return (Resource) args[1];
+
+ });
+ when(resourceBusinessLogic.createResourceByDao(
+ any(Resource.class), any(User.class), any(AuditingActionEnum.class), anyBoolean(), anyBoolean())).thenAnswer(
+ (Answer<Either<Resource, ResponseFormat>>) invocation -> {
+ Object[] args = invocation.getArguments();
+ return Either.left((Resource) args[0]);
+
+ });
+ when(resourceBusinessLogic.validateResourceBeforeCreate(
+ any(Resource.class), any(User.class), any(AuditingActionEnum.class), eq(false), eq(null))).thenAnswer(
+ (Answer<Either<Resource, ResponseFormat>>) invocation -> {
+ Object[] args = invocation.getArguments();
+ return Either.left((Resource) args[0]);
+
+ });
+
+ when(resourceBusinessLogic.validatePropertiesDefaultValues(any(Resource.class))).thenReturn(true);
+ }
+
+ private ResponseFormat createGeneralErrorInfo() {
+ ResponseFormat responseFormat = new ResponseFormat(500);
+ responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
+ return responseFormat;
+ }
+
+ private UploadResourceInfo createDummyResourceMD() {
+ UploadResourceInfo resourceMD = new UploadResourceInfo();
+ resourceMD.setName("tosca.nodes.BlockStorage");
+ resourceMD.setPayloadName("payLoad");
+ resourceMD.addSubCategory("Generic", "Infrastructure");
+ resourceMD.setContactId("ya107f");
+ resourceMD.setResourceIconPath("defaulticon");
+ resourceMD.setTags(Collections.singletonList("BlockStorage"));
+ resourceMD.setDescription(
+ "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.");
+ resourceMD.setResourceVendorModelNumber("vendorReleaseNumber");
+ resourceMD.setNormative(true);
+ return resourceMD;
+ }
+
+ private void testSetProperties(Resource resource) {
+ List<PropertyDefinition> propertiesList = resource.getProperties();
+
+ Map<String, PropertyDefinition> properties = new HashMap<>();
+ for (PropertyDefinition propertyDefinition : propertiesList) {
+ properties.put(propertyDefinition.getName(), propertyDefinition);
+ }
+
+ assertEquals(3, properties.size());
+ assertTrue(properties.containsKey("size"));
+ PropertyDefinition propertyDefinition = properties.get("size");
+ assertEquals("scalar-unit.size", propertyDefinition.getType());
+ assertEquals(1, propertyDefinition.getConstraints().size());
+ PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
+ assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
+
+ assertTrue(properties.containsKey("volume_id"));
+ propertyDefinition = properties.get("volume_id");
+ assertEquals("string", propertyDefinition.getType());
+ assertFalse(propertyDefinition.isRequired());
+
+ assertTrue(properties.containsKey("snapshot_id"));
+ propertyDefinition = properties.get("snapshot_id");
+ assertEquals("string", propertyDefinition.getType());
+ assertFalse(propertyDefinition.isRequired());
+
+ }
+
+ private ImmutablePair<Resource, ActionStatus> reimportVfc(final Resource resource, final String jsonContent) {
+ List<PropertyDefinition> propertiesList = resource.getProperties();
+ if (CollectionUtils.isEmpty(propertiesList)) {
+ propertiesList = new ArrayList<>();
+ }
+ final PropertyDefinition propertyDefinition = new PropertyDefinition();
+ propertyDefinition.setName("oneMore");
+ propertyDefinition.setUserCreated(true);
+ propertyDefinition.setType("boolean");
+ propertiesList.add(propertyDefinition);
+ resource.setProperties(propertiesList);
+
+ Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
+ if (MapUtils.isEmpty(interfaces)) {
+ interfaces = new HashMap<>();
+ }
+ final InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
+ interfaceDefinition.setType("tosca.interfaces.relationship.Configure");
+ interfaceDefinition.setUserCreated(true);
+ final OperationDataDefinition operationDataDefinition = new OperationDataDefinition();
+ operationDataDefinition.setName("add_source");
+ final Map<String, OperationDataDefinition> operationDataDefinitionMap = new HashMap<>();
+ operationDataDefinitionMap.put(operationDataDefinition.getName(), operationDataDefinition);
+ interfaceDefinition.setOperations(operationDataDefinitionMap);
+ interfaces.put(interfaceDefinition.getType(), interfaceDefinition);
+ resource.setInterfaces(interfaces);
+
+ return importManager.importNormativeResource(jsonContent, resourceMD, null, user, true, true, false);
+
+ }
+
+ private void testPropertiesAfterReimport(Resource resource) {
+ List<PropertyDefinition> propertiesList = resource.getProperties();
+
+ Map<String, PropertyDefinition> properties = new HashMap<>();
+ for (PropertyDefinition propertyDefinition : propertiesList) {
+ properties.put(propertyDefinition.getName(), propertyDefinition);
+ }
+
+ assertEquals(4, properties.size());
+
+ assertTrue(properties.containsKey("size"));
+ PropertyDefinition propertyDefinition = properties.get("size");
+ assertEquals("scalar-unit.size", propertyDefinition.getType());
+ assertEquals(1, propertyDefinition.getConstraints().size());
+ PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
+ assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
+
+ assertTrue(properties.containsKey("volume_id"));
+ propertyDefinition = properties.get("volume_id");
+ assertEquals("string", propertyDefinition.getType());
+ assertFalse(propertyDefinition.isRequired());
+ assertFalse(propertyDefinition.isUserCreated());
+
+ assertTrue(properties.containsKey("snapshot_id"));
+ propertyDefinition = properties.get("snapshot_id");
+ assertEquals("string", propertyDefinition.getType());
+ assertFalse(propertyDefinition.isRequired());
+ assertFalse(propertyDefinition.isUserCreated());
+
+ assertTrue(properties.containsKey("oneMore"));
+ propertyDefinition = properties.get("oneMore");
+ assertEquals("boolean", propertyDefinition.getType());
+ assertFalse(propertyDefinition.isRequired());
+ assertTrue(propertyDefinition.isUserCreated());
+ }
+
+ private void testSetCapabilities(Resource resource) {
+ Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
+ assertEquals(3, capabilities.size());
+ assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
+ List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
+ CapabilityDefinition capability = capabilityList.get(0);
+ assertEquals("tosca.capabilities.Endpoint", capability.getType());
+ assertEquals("data_endpoint", capability.getName());
+
+ assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
+ capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
+ capability = capabilityList.get(0);
+ assertEquals("tosca.capabilities.Endpoint.Admin", capability.getType());
+ assertEquals("admin_endpoint", capability.getName());
+
+ assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
+ capabilityList = capabilities.get("tosca.capabilities.Container");
+ capability = capabilityList.get(0);
+ assertEquals("tosca.capabilities.Container", capability.getType());
+ assertEquals("host", capability.getName());
+
+ List<String> validSourceTypes = capability.getValidSourceTypes();
+ assertEquals(1, validSourceTypes.size());
+ assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0));
+
+ }
+
+ private void testSetRequirements(Resource resource) {
+ Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
+ assertEquals(2, requirements.size());
+
+ assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
+ List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
+ RequirementDefinition requirement = requirementList.get(0);
+ assertEquals("tosca.capabilities.network.Linkable", requirement.getCapability());
+ assertEquals("tosca.relationships.network.LinksTo", requirement.getRelationship());
+ assertEquals("link", requirement.getName());
+
+ assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
+ requirementList = requirements.get("tosca.capabilities.network.Bindable");
+ requirement = requirementList.get(0);
+ assertEquals("tosca.capabilities.network.Bindable", requirement.getCapability());
+ assertEquals("tosca.relationships.network.BindsTo", requirement.getRelationship());
+ assertEquals("binding", requirement.getName());
+
+ }
+
+ private void assertSetInterfaceImplementation(final Resource resource) {
+ final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
+ assertNotNull(interfaces);
+ assertEquals(1, interfaces.size());
+ final InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
+ assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
+ Map<String, OperationDataDefinition> operations = interfaceDefinition.getOperations();
+ operations.values().forEach(operationDataDefinition ->
+ assertTrue(operations.containsKey(operationDataDefinition.getName())));
+ }
+
+ private void assertSetInterfaceImplementationAfterReimport(final Resource resource) {
+ final Map<String, InterfaceDefinition> interfaces = resource.getInterfaces();
+ assertNotNull(interfaces);
+ assertEquals(2, interfaces.size());
+
+ InterfaceDefinition interfaceDefinition = interfaces.get("tosca.interfaces.node.lifecycle.Standard");
+ assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
+ assertFalse(interfaceDefinition.isUserCreated());
+ final Map<String, OperationDataDefinition> operations_1 = interfaceDefinition.getOperations();
+ operations_1.values().forEach(operationDataDefinition -> assertTrue(operations_1.containsKey(operationDataDefinition.getName())));
+
+ interfaceDefinition = interfaces.get("tosca.interfaces.relationship.Configure");
+ assertTrue(interfaces.containsKey(interfaceDefinition.getType()));
+ assertTrue(interfaceDefinition.isUserCreated());
+ final Map<String, OperationDataDefinition> operations_2 = interfaceDefinition.getOperations();
+ operations_2.values().forEach(operationDataDefinition -> assertTrue(operations_2.containsKey(operationDataDefinition.getName())));
+ }
+
+ private void testSetDerivedFrom(Resource resource) {
+ assertEquals(1, resource.getDerivedFrom().size());
+ assertEquals("tosca.nodes.Root", resource.getDerivedFrom().get(0));
+
+ }
+
+ private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
+ assertEquals(resource.getDescription(), resourceMD.getDescription());
+ assertEquals(resource.getIcon(), resourceMD.getResourceIconPath());
+ assertEquals(resource.getName(), resourceMD.getName());
+ assertEquals(resource.getResourceVendorModelNumber(), resourceMD.getResourceVendorModelNumber());
+ assertEquals(resource.getContactId(), resourceMD.getContactId());
+ assertEquals(resource.getCreatorUserId(), resourceMD.getContactId());
+ assertEquals(resourceMD.getTags().size(), resource.getTags().size());
+ for (String tag : resource.getTags()) {
+ assertTrue(resourceMD.getTags().contains(tag));
+ }
+ assertEquals(resourceMD.isNormative(), resource.getComponentMetadataDefinition().getMetadataDataDefinition().isNormative());
+ }
+
+ private void testSetConstantMetaData(Resource resource) {
+ assertEquals(resource.getVersion(), TypeUtils.getFirstCertifiedVersionVersion());
+ assertSame(ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE, resource.getLifecycleState());
+ assertEquals(ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION, resource.isHighestVersion());
+ assertEquals(ImportUtils.Constants.VENDOR_NAME, resource.getVendorName());
+ assertEquals(ImportUtils.Constants.VENDOR_RELEASE, resource.getVendorRelease());
+ }
+
+ protected ServiceCsarInfo getCsarInfo() {
+ String csarUuid = "0010";
+ User user = new User("jh0003");
+
+ try {
+ File csarFile = new File(
+ ResourceImportManagerTest.class.getClassLoader().getResource("csars/service-Etsiwithchild-csar.csar").toURI());
+ Map<String, byte[]> csar = ZipUtils.readZip(csarFile, false);
+
+ String vfReousrceName = "resouceName";
+ String mainTemplateName = "Definitions/service-Etsiwithchild-template.yml";
+
+ Optional<String> keyOp = csar.keySet().stream().filter(k -> k.endsWith("service-Etsiwithchild-template.yml")).findAny();
+ byte[] mainTemplateService = keyOp.map(csar::get).orElse(null);
+ assertNotNull(mainTemplateService);
+ final String mainTemplateContent = new String(mainTemplateService);
+
+ return new ServiceCsarInfo(user, csarUuid, csar, vfReousrceName, null, mainTemplateName, mainTemplateContent, false,
+ mock(ModelOperation.class));
+ } catch (URISyntaxException | ZipException e) {
+ fail(e);
+ }
+ return null;
+ }
- String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-blockStorage.yml");
-
- Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
- assertTrue(createResource.isLeft());
- Resource resource = createResource.left().value().left;
-
- testSetConstantMetaData(resource);
- testSetMetaDataFromJson(resource, resourceMD);
-
- testSetDerivedFrom(resource);
- testSetProperties(resource);
-
- Mockito.verify(resourceBusinessLogic, Mockito.times(1)).propagateStateToCertified(Mockito.eq(user), Mockito.eq(resource), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false));
- }
-
- @Test
- public void testResourceCreationFailed() throws IOException {
- UploadResourceInfo resourceMD = createDummyResourceMD();
- User user = new User();
- user.setUserId(resourceMD.getContactId());
- Either<User, ActionStatus> eitherUser = Either.left(user);
- when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherUser);
- ResponseFormat dummyResponseFormat = createGeneralErrorInfo();
-
- when(responseFormatManager.getResponseFormat(ActionStatus.GENERAL_ERROR)).thenReturn(dummyResponseFormat);
- setResourceBusinessLogicMock();
-
- String jsonContent = "this is an invalid yml!";
-
- Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
- assertTrue(createResource.isRight());
- ResponseFormat errorInfoFromTest = createResource.right().value();
- assertTrue(errorInfoFromTest.getStatus().equals(dummyResponseFormat.getStatus()));
- assertTrue(errorInfoFromTest.getMessageId().equals(dummyResponseFormat.getMessageId()));
- assertTrue(errorInfoFromTest.getFormattedMessage().equals(dummyResponseFormat.getFormattedMessage()));
- Mockito.verify(log).debug(Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.any(Exception.class));
- // Mockito.verify(log).error(Mockito.anyString(), Mockito.anyString(),
- // Mockito.anyString());
-
- Mockito.verify(resourceBusinessLogic, Mockito.times(0)).createOrUpdateResourceByImport(Mockito.any(Resource.class), Mockito.eq(user), Mockito.eq(true), Mockito.eq(false), Mockito.eq(true));
-
- Mockito.verify(resourceBusinessLogic, Mockito.times(0)).propagateStateToCertified(Mockito.eq(user), Mockito.any(Resource.class), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false));
-
- }
-
- @Test
- public void testResourceCreationWithCapabilities() throws IOException {
- UploadResourceInfo resourceMD = createDummyResourceMD();
- User user = new User();
- user.setUserId(resourceMD.getContactId());
- Either<User, ActionStatus> eitherUser = Either.left(user);
-
- when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherUser);
-
- setResourceBusinessLogicMock();
-
- String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml");
-
- Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
- assertTrue(createResource.isLeft());
- Resource resource = createResource.left().value().left;
- testSetCapabilities(resource);
-
- Mockito.verify(resourceBusinessLogic, Mockito.times(1)).propagateStateToCertified(Mockito.eq(user), Mockito.eq(resource), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false));
- Mockito.verify(resourceBusinessLogic, Mockito.times(1)).createOrUpdateResourceByImport(resource, user, true, false, true);
-
- }
-
- @Test
- public void testResourceCreationWithRequirments() throws IOException {
- UploadResourceInfo resourceMD = createDummyResourceMD();
- User user = new User();
- user.setUserId(resourceMD.getContactId());
- Either<User, ActionStatus> eitherUser = Either.left(user);
-
- when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherUser);
-
- setResourceBusinessLogicMock();
-
- String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml");
-
- Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat> createResource = importManager.importNormativeResource(jsonContent, resourceMD, user, true, true);
- assertTrue(createResource.isLeft());
- testSetRequirments(createResource.left().value().left);
-
- }
-
- private void setResourceBusinessLogicMock() {
- when(resourceBusinessLogic.getUserAdmin()).thenReturn(userAdmin);
- when(resourceBusinessLogic.createOrUpdateResourceByImport(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.anyBoolean()))
- .thenAnswer(new Answer<Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat>>() {
- public Either<ImmutablePair<Resource, ActionStatus>, ResponseFormat> answer(InvocationOnMock invocation) throws Throwable {
- Object[] args = invocation.getArguments();
- return Either.left(new ImmutablePair<Resource, ActionStatus>((Resource) args[0], ActionStatus.CREATED));
-
- }
- });
- when(resourceBusinessLogic.propagateStateToCertified(Mockito.any(User.class), Mockito.any(Resource.class), Mockito.any(LifecycleChangeInfoWithAction.class), Mockito.eq(false), Mockito.eq(true), Mockito.eq(false)))
- .thenAnswer(new Answer<Either<Resource, ResponseFormat>>() {
- public Either<Resource, ResponseFormat> answer(InvocationOnMock invocation) throws Throwable {
- Object[] args = invocation.getArguments();
- return Either.left((Resource) args[1]);
-
- }
- });
- when(resourceBusinessLogic.createResourceByDao(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.any(AuditingActionEnum.class), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(EnumMap.class))).thenAnswer(new Answer<Either<Resource, ResponseFormat>>() {
- public Either<Resource, ResponseFormat> answer(InvocationOnMock invocation) throws Throwable {
- Object[] args = invocation.getArguments();
- return Either.left((Resource) args[0]);
-
- }
- });
- when(resourceBusinessLogic.validateResourceBeforeCreate(Mockito.any(Resource.class), Mockito.any(User.class), Mockito.any(AuditingActionEnum.class), Mockito.eq(false))).thenAnswer(new Answer<Either<Resource, ResponseFormat>>() {
- public Either<Resource, ResponseFormat> answer(InvocationOnMock invocation) throws Throwable {
- Object[] args = invocation.getArguments();
- return Either.left((Resource) args[0]);
-
- }
- });
-
- Either<Boolean, ResponseFormat> either = Either.left(true);
- when(resourceBusinessLogic.validatePropertiesDefaultValues(Mockito.any(Resource.class))).thenReturn(either);
- }
-
- public ResponseFormat createGeneralErrorInfo() {
- ResponseFormat responseFormat = new ResponseFormat(500);
- responseFormat.setPolicyException(new PolicyException("POL5000", "Error: Internal Server Error. Please try again later", null));
- return responseFormat;
- }
-
- private UploadResourceInfo createDummyResourceMD() {
- UploadResourceInfo resourceMD = new UploadResourceInfo();
- resourceMD.setName("tosca.nodes.BlockStorage");
- resourceMD.addSubCategory("Generic", "Infrastructure");
- resourceMD.setContactId("ya107f");
- resourceMD.setResourceIconPath("defaulticon");
- resourceMD.setTags(Arrays.asList(new String[] { "BlockStorage" }));
- resourceMD.setDescription("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.");
- return resourceMD;
- }
-
- private void testSetProperties(Resource resource) {
- List<PropertyDefinition> propertiesList = resource.getProperties();
-
- Map<String, PropertyDefinition> properties = new HashMap<String, PropertyDefinition>();
- for (PropertyDefinition propertyDefinition : propertiesList) {
- properties.put(propertyDefinition.getName(), propertyDefinition);
- }
-
- assertTrue(properties.size() == 3);
- assertTrue(properties.containsKey("size"));
- PropertyDefinition propertyDefinition = properties.get("size");
- assertTrue(propertyDefinition.getType().equals("scalar-unit.size"));
- assertTrue(propertyDefinition.getConstraints().size() == 1);
- PropertyConstraint propertyConstraint = propertyDefinition.getConstraints().get(0);
- assertTrue(propertyConstraint instanceof GreaterOrEqualConstraint);
-
- assertTrue(properties.containsKey("volume_id"));
- propertyDefinition = properties.get("volume_id");
- assertTrue(propertyDefinition.getType().equals("string"));
- assertTrue(propertyDefinition.isRequired() == false);
-
- assertTrue(properties.containsKey("snapshot_id"));
- propertyDefinition = properties.get("snapshot_id");
- assertTrue(propertyDefinition.getType().equals("string"));
- assertTrue(propertyDefinition.isRequired() == false);
-
- }
-
- private void testSetCapabilities(Resource resource) {
- Map<String, List<CapabilityDefinition>> capabilities = resource.getCapabilities();
- assertTrue(capabilities.size() == 3);
- assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint"));
- List<CapabilityDefinition> capabilityList = capabilities.get("tosca.capabilities.Endpoint");
- CapabilityDefinition capability = capabilityList.get(0);
- assertTrue(capability.getType().equals("tosca.capabilities.Endpoint"));
- assertTrue(capability.getName().equals("data_endpoint"));
-
- assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint.Admin"));
- capabilityList = capabilities.get("tosca.capabilities.Endpoint.Admin");
- capability = capabilityList.get(0);
- assertTrue(capability.getType().equals("tosca.capabilities.Endpoint.Admin"));
- assertTrue(capability.getName().equals("admin_endpoint"));
-
- assertTrue(capabilities.containsKey("tosca.capabilities.Container"));
- capabilityList = capabilities.get("tosca.capabilities.Container");
- capability = capabilityList.get(0);
- assertTrue(capability.getType().equals("tosca.capabilities.Container"));
- assertTrue(capability.getName().equals("host"));
-
- List<String> validSourceTypes = capability.getValidSourceTypes();
- assertTrue(validSourceTypes.size() == 1);
- assertTrue(validSourceTypes.get(0).equals("tosca.nodes.WebApplication"));
-
- }
-
- private void testSetRequirments(Resource resource) {
- Map<String, List<RequirementDefinition>> requirements = resource.getRequirements();
- assertTrue(requirements.size() == 2);
-
- assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable"));
- List<RequirementDefinition> requirementList = requirements.get("tosca.capabilities.network.Linkable");
- RequirementDefinition requirement = requirementList.get(0);
- assertTrue(requirement.getCapability().equals("tosca.capabilities.network.Linkable"));
- assertTrue(requirement.getRelationship().equals("tosca.relationships.network.LinksTo"));
- assertTrue(requirement.getName().equals("link"));
-
- assertTrue(requirements.containsKey("tosca.capabilities.network.Bindable"));
- requirementList = requirements.get("tosca.capabilities.network.Bindable");
- requirement = requirementList.get(0);
- assertTrue(requirement.getCapability().equals("tosca.capabilities.network.Bindable"));
- assertTrue(requirement.getRelationship().equals("tosca.relationships.network.BindsTo"));
- assertTrue(requirement.getName().equals("binding"));
-
- }
-
- private void testSetDerivedFrom(Resource resource) {
- assertTrue(resource.getDerivedFrom().size() == 1);
- assertTrue(resource.getDerivedFrom().get(0).equals("tosca.nodes.Root"));
-
- }
-
- private void testSetMetaDataFromJson(Resource resource, UploadResourceInfo resourceMD) {
-
- // assertTrue( resource.getCategory().equals(resourceMD.getCategory())
- // );
- assertTrue(resource.getDescription().equals(resourceMD.getDescription()));
- assertTrue(resource.getIcon().equals(resourceMD.getResourceIconPath()));
- assertTrue(resource.getName().equals(resourceMD.getName()));
-
- assertTrue(resource.getContactId().equals(resourceMD.getContactId()));
- assertTrue(resource.getCreatorUserId().equals(resourceMD.getContactId()));
-
- // assertTrue( resource.isAbstract() ==
- // Constants.ABSTRACT_CATEGORY.equals(resourceMD.getCategory()));
-
- assertTrue(resourceMD.getTags().size() == resource.getTags().size());
- for (String tag : resource.getTags()) {
- assertTrue(resourceMD.getTags().contains(tag));
- }
-
- }
-
- private void testSetConstantMetaData(Resource resource) {
- assertTrue(resource.getVersion().equals(ImportUtils.Constants.FIRST_CERTIFIED_VERSION_VERSION));
- assertTrue(resource.getLifecycleState() == ImportUtils.Constants.NORMATIVE_TYPE_LIFE_CYCLE);
- assertTrue(resource.isHighestVersion() == ImportUtils.Constants.NORMATIVE_TYPE_HIGHEST_VERSION);
- assertTrue(resource.getVendorName().equals(ImportUtils.Constants.VENDOR_NAME));
- assertTrue(resource.getVendorRelease().equals(ImportUtils.Constants.VENDOR_RELEASE));
- }
}