X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-be%2Fsrc%2Ftest%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Fcomponents%2FResourceImportManagerTest.java;h=d64aaf8cd0e545bbae15c540ad618cd7480fdf3b;hb=f4668df71072c8ecd4b9d05423006265b36a6ef7;hp=f0b28653738f7ff47cc5d11b2c470a9739f8a934;hpb=75aacbbe1acf78fa53378f07f0a8c7769449a17e;p=sdc.git diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java index f0b2865373..d64aaf8cd0 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/ResourceImportManagerTest.java @@ -7,366 +7,785 @@ * 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 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 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 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 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 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 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 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 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 interfaceTypes = new HashMap<>(); + final InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard"); + Map 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 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 interfaceTypes = new HashMap<>(); + final InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard"); + Map 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 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 interfaceTypes = new HashMap<>(); + final InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard"); + Map 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 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 interfaceTypes = new HashMap<>(); + final InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setType("tosca.interfaces.node.lifecycle.Standard"); + Map 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 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 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 nodeTypeMetadataList = new ArrayList<>(); + Map allTypesToCreate = new HashMap<>(); + ServiceCsarInfo csarInfo = getCsarInfo(); + List 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>) 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) 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>) 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>) 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 propertiesList = resource.getProperties(); + + Map 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 reimportVfc(final Resource resource, final String jsonContent) { + List 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 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 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 propertiesList = resource.getProperties(); + + Map 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> capabilities = resource.getCapabilities(); + assertEquals(3, capabilities.size()); + assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint")); + List 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 validSourceTypes = capability.getValidSourceTypes(); + assertEquals(1, validSourceTypes.size()); + assertEquals("tosca.nodes.WebApplication", validSourceTypes.get(0)); + + } + + private void testSetRequirements(Resource resource) { + Map> requirements = resource.getRequirements(); + assertEquals(2, requirements.size()); + + assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable")); + List 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 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 operations = interfaceDefinition.getOperations(); + operations.values().forEach(operationDataDefinition -> + assertTrue(operations.containsKey(operationDataDefinition.getName()))); + } + + private void assertSetInterfaceImplementationAfterReimport(final Resource resource) { + final Map 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 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 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 csar = ZipUtils.readZip(csarFile, false); + + String vfReousrceName = "resouceName"; + String mainTemplateName = "Definitions/service-Etsiwithchild-template.yml"; + + Optional 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, 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 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, 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 eitherUser = Either.left(user); - - when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherUser); - - setResourceBusinessLogicMock(); - - String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml"); - - Either, 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 eitherUser = Either.left(user); - - when(userAdmin.getUser(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(eitherUser); - - setResourceBusinessLogicMock(); - - String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-port.yml"); - - Either, 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, ResponseFormat>>() { - public Either, ResponseFormat> answer(InvocationOnMock invocation) throws Throwable { - Object[] args = invocation.getArguments(); - return Either.left(new ImmutablePair((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>() { - public Either 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>() { - public Either 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>() { - public Either answer(InvocationOnMock invocation) throws Throwable { - Object[] args = invocation.getArguments(); - return Either.left((Resource) args[0]); - - } - }); - - Either 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 propertiesList = resource.getProperties(); - - Map properties = new HashMap(); - 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> capabilities = resource.getCapabilities(); - assertTrue(capabilities.size() == 3); - assertTrue(capabilities.containsKey("tosca.capabilities.Endpoint")); - List 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 validSourceTypes = capability.getValidSourceTypes(); - assertTrue(validSourceTypes.size() == 1); - assertTrue(validSourceTypes.get(0).equals("tosca.nodes.WebApplication")); - - } - - private void testSetRequirments(Resource resource) { - Map> requirements = resource.getRequirements(); - assertTrue(requirements.size() == 2); - - assertTrue(requirements.containsKey("tosca.capabilities.network.Linkable")); - List 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)); - } }