X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-be%2Fsrc%2Ftest%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Fcomponents%2Fimpl%2FResourceBusinessLogicTest.java;h=69b3f1d660539a8fce211c5e6d81be23d82724b8;hb=0c274e9356fc77c53340828b0ec18869dad71631;hp=0e276369015ddef76b3dde14704392c196e666a1;hpb=2b123f57f5fab492493c12ddc9c14b0c77e39e2d;p=sdc.git diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java index 0e27636901..69b3f1d660 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java @@ -20,105 +20,114 @@ package org.openecomp.sdc.be.components.impl; +import static org.assertj.core.api.Java6Assertions.assertThat; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.times; import static org.mockito.Mockito.when; +import fj.data.Either; +import java.io.IOException; import java.lang.reflect.Method; import java.util.ArrayList; +import java.util.Arrays; import java.util.EnumMap; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Set; -import java.util.regex.Pattern; +import java.util.Optional; import java.util.stream.Collectors; - +import java.util.stream.Stream; import javax.servlet.ServletContext; - import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Assert; import org.junit.Before; -import org.junit.Ignore; import org.junit.Test; import org.mockito.InjectMocks; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.openecomp.sdc.ElementOperationMock; -import org.openecomp.sdc.be.auditing.api.IAuditingManager; -import org.openecomp.sdc.be.auditing.impl.AuditingLogFormatUtil; import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.components.ArtifactsResolver; +import org.openecomp.sdc.be.components.csar.CsarArtifactsAndGroupsBusinessLogic; +import org.openecomp.sdc.be.components.csar.CsarBusinessLogic; +import org.openecomp.sdc.be.components.csar.CsarInfo; import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationEnum; -import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo; +import org.openecomp.sdc.be.components.impl.exceptions.ComponentException; +import org.openecomp.sdc.be.components.impl.generic.GenericTypeBusinessLogic; import org.openecomp.sdc.be.components.lifecycle.LifecycleBusinessLogic; import org.openecomp.sdc.be.components.lifecycle.LifecycleChangeInfoWithAction; +import org.openecomp.sdc.be.components.merge.resource.ResourceDataMergeBusinessLogic; +import org.openecomp.sdc.be.components.merge.utils.MergeInstanceUtils; +import org.openecomp.sdc.be.components.validation.UserValidations; +import org.openecomp.sdc.be.components.validation.component.ComponentContactIdValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentDescriptionValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentFieldValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentIconValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentNameValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentProjectCodeValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentTagsValidator; +import org.openecomp.sdc.be.components.validation.component.ComponentValidator; import org.openecomp.sdc.be.config.ConfigurationManager; import org.openecomp.sdc.be.dao.api.ActionStatus; -import org.openecomp.sdc.be.dao.jsongraph.TitanDao; +import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao; import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum; +import org.openecomp.sdc.be.datamodel.utils.UiComponentDataConverter; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.facade.operations.CatalogOperation; import org.openecomp.sdc.be.impl.ComponentsUtils; import org.openecomp.sdc.be.impl.WebAppContextWrapper; -import org.openecomp.sdc.be.info.ArtifactTemplateInfo; -import org.openecomp.sdc.be.info.MergedArtifactInfo; import org.openecomp.sdc.be.model.ArtifactDefinition; -import org.openecomp.sdc.be.model.CapabilityDefinition; import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.ComponentInstance; -import org.openecomp.sdc.be.model.ComponentInstanceInput; -import org.openecomp.sdc.be.model.ComponentInstanceProperty; -import org.openecomp.sdc.be.model.CsarInfo; import org.openecomp.sdc.be.model.DataTypeDefinition; import org.openecomp.sdc.be.model.GroupDefinition; -import org.openecomp.sdc.be.model.GroupProperty; -import org.openecomp.sdc.be.model.GroupTypeDefinition; -import org.openecomp.sdc.be.model.HeatParameterDefinition; import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.LifeCycleTransitionEnum; import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.NodeTypeInfo; -import org.openecomp.sdc.be.model.ParsedToscaYamlInfo; import org.openecomp.sdc.be.model.PropertyDefinition; -import org.openecomp.sdc.be.model.RequirementCapabilityRelDef; -import org.openecomp.sdc.be.model.RequirementDefinition; import org.openecomp.sdc.be.model.Resource; -import org.openecomp.sdc.be.model.UploadCapInfo; -import org.openecomp.sdc.be.model.UploadComponentInstanceInfo; -import org.openecomp.sdc.be.model.UploadPropInfo; -import org.openecomp.sdc.be.model.UploadReqInfo; -import org.openecomp.sdc.be.model.UploadResourceInfo; import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; -import org.openecomp.sdc.be.model.category.CategoryDefinition; -import org.openecomp.sdc.be.model.category.SubCategoryDefinition; -import org.openecomp.sdc.be.model.jsontitan.operations.NodeTemplateOperation; -import org.openecomp.sdc.be.model.jsontitan.operations.NodeTypeOperation; -import org.openecomp.sdc.be.model.jsontitan.operations.TopologyTemplateOperation; -import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; -import org.openecomp.sdc.be.model.operations.api.ICacheMangerOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ArtifactsOperations; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.InterfaceOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTemplateOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.NodeTypeOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.TopologyTemplateOperation; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.operations.StorageException; import org.openecomp.sdc.be.model.operations.api.ICapabilityTypeOperation; import org.openecomp.sdc.be.model.operations.api.IElementOperation; -import org.openecomp.sdc.be.model.operations.api.IPropertyOperation; +import org.openecomp.sdc.be.model.operations.api.IGroupInstanceOperation; +import org.openecomp.sdc.be.model.operations.api.IGroupOperation; +import org.openecomp.sdc.be.model.operations.api.IGroupTypeOperation; +import org.openecomp.sdc.be.model.operations.api.IInterfaceLifecycleOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.CacheMangerOperation; import org.openecomp.sdc.be.model.operations.impl.CsarOperation; import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation; +import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; +import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; import org.openecomp.sdc.be.model.tosca.ToscaPropertyType; import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.tosca.CsarUtils; import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo; -import org.openecomp.sdc.be.ui.model.UiComponentDataTransfer; -import org.openecomp.sdc.be.user.IUserBusinessLogic; +import org.openecomp.sdc.be.tosca.ToscaExportHandler; import org.openecomp.sdc.be.user.Role; import org.openecomp.sdc.be.user.UserBusinessLogic; import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum; import org.openecomp.sdc.common.api.ArtifactTypeEnum; import org.openecomp.sdc.common.api.ConfigurationSource; import org.openecomp.sdc.common.api.Constants; -import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; import org.openecomp.sdc.common.impl.ExternalConfiguration; import org.openecomp.sdc.common.impl.FSConfigurationSource; import org.openecomp.sdc.common.util.GeneralUtility; @@ -128,62 +137,109 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.web.context.WebApplicationContext; -import com.att.nsa.cambria.test.support.CambriaBatchingPublisherMock.Entry; -import com.google.common.base.Equivalence.Wrapper; -import com.netflix.astyanax.connectionpool.Operation; - -import fj.data.Either; - public class ResourceBusinessLogicTest { - private static Logger log = LoggerFactory.getLogger(ResourceBusinessLogicTest.class.getName()); - public static final String RESOURCE_CATEGORY = "Network Layer 2-3/Router"; - public static final String RESOURCE_CATEGORY1 = "Network Layer 2-3"; - public static final String RESOURCE_SUBCATEGORY = "Router"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be"); + ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); + private static final Logger log = LoggerFactory.getLogger(ResourceBusinessLogicTest.class); + private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3"; + private static final String RESOURCE_SUBCATEGORY = "Router"; + + private static final String UPDATED_SUBCATEGORY = "Gateway"; - public static final String UPDATED_CATEGORY = "Network Layer 2-3/Gateway"; - public static final String UPDATED_SUBCATEGORY = "Gateway"; + private String resourceId = "resourceId1"; + private String operationId = "uniqueId1"; + Resource resourceUpdate; - public static final String RESOURCE_NAME = "My-Resource_Name with space"; + private static final String RESOURCE_NAME = "My-Resource_Name with space"; + private static final String RESOURCE_TOSCA_NAME = "My-Resource_Tosca_Name"; + private static final String GENERIC_ROOT_NAME = "tosca.nodes.Root"; private static final String GENERIC_VF_NAME = "org.openecomp.resource.abstract.nodes.VF"; - private static final String GENERIC_VFC_NAME = "org.openecomp.resource.abstract.nodes.VFC"; + private static final String GENERIC_CR_NAME = "org.openecomp.resource.abstract.nodes.CR"; private static final String GENERIC_PNF_NAME = "org.openecomp.resource.abstract.nodes.PNF"; final ServletContext servletContext = Mockito.mock(ServletContext.class); - IAuditingManager iAuditingManager = null; IElementOperation mockElementDao; - TitanDao mockTitanDao = Mockito.mock(TitanDao.class); + JanusGraphDao mockJanusGraphDao = Mockito.mock(JanusGraphDao.class); UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class); ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class); NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class); NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class); TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class); final LifecycleBusinessLogic lifecycleBl = Mockito.mock(LifecycleBusinessLogic.class); + final CatalogOperation catalogOperation = Mockito.mock(CatalogOperation.class); final ICapabilityTypeOperation capabilityTypeOperation = Mockito.mock(ICapabilityTypeOperation.class); - final IPropertyOperation propertyOperation = Mockito.mock(IPropertyOperation.class); + final PropertyOperation propertyOperation = Mockito.mock(PropertyOperation.class); final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class); WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class); + UserValidations userValidations = Mockito.mock(UserValidations.class); WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class); - AuditingLogFormatUtil auditingLogFormatter = Mockito.mock(AuditingLogFormatUtil.class); + IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class); + ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class); + IElementOperation elementDao = new ElementOperationMock(); + + CsarUtils csarUtils = Mockito.mock(CsarUtils.class); + UserBusinessLogic userBusinessLogic = Mockito.mock(UserBusinessLogic.class); + IGroupOperation groupOperation = Mockito.mock(IGroupOperation.class); + IGroupInstanceOperation groupInstanceOperation = Mockito.mock(IGroupInstanceOperation.class); + IGroupTypeOperation groupTypeOperation = Mockito.mock(IGroupTypeOperation.class); + GroupBusinessLogic groupBusinessLogic = Mockito.mock(GroupBusinessLogic.class); + InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class); + ArtifactsOperations artifactToscaOperation = Mockito.mock(ArtifactsOperations.class); + private PropertyBusinessLogic propertyBusinessLogic = Mockito.mock(PropertyBusinessLogic.class); + ArtifactsResolver artifactsResolver = Mockito.mock(ArtifactsResolver.class); + InterfaceLifecycleOperation interfaceLifecycleTypeOperation = Mockito.mock(InterfaceLifecycleOperation.class); + ComponentInstanceBusinessLogic componentInstanceBusinessLogic = Mockito.mock(ComponentInstanceBusinessLogic.class); + ResourceImportManager resourceImportManager = Mockito.mock(ResourceImportManager.class); + InputsBusinessLogic inputsBusinessLogic = Mockito.mock(InputsBusinessLogic.class); + CompositionBusinessLogic compositionBusinessLogic = Mockito.mock(CompositionBusinessLogic.class); + ResourceDataMergeBusinessLogic resourceDataMergeBusinessLogic = Mockito.mock(ResourceDataMergeBusinessLogic.class); + CsarArtifactsAndGroupsBusinessLogic csarArtifactsAndGroupsBusinessLogic = Mockito.mock(CsarArtifactsAndGroupsBusinessLogic.class); + MergeInstanceUtils mergeInstanceUtils = Mockito.mock(MergeInstanceUtils.class); + UiComponentDataConverter uiComponentDataConverter = Mockito.mock(UiComponentDataConverter.class); + ToscaExportHandler toscaExportHandler = Mockito.mock(ToscaExportHandler.class); + + + @InjectMocks - ResourceBusinessLogic bl = new ResourceBusinessLogic(); ResponseFormatManager responseManager = null; - AuditingManager auditingManager = Mockito.mock(AuditingManager.class); GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class); User user = null; Resource resourceResponse = null; Resource genericVF = null; + Resource genericCR = null; Resource genericVFC = null; Resource genericPNF = null; - ComponentsUtils componentsUtils = new ComponentsUtils(); - ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic(); + Resource rootType = null; + ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class)); + ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic(artifactCassandraDao, toscaExportHandler, csarUtils, lifecycleBl, + userBusinessLogic, artifactsResolver, elementDao, groupOperation, groupInstanceOperation, groupTypeOperation, + interfaceOperation, interfaceLifecycleTypeOperation, artifactToscaOperation); CsarOperation csarOperation = Mockito.mock(CsarOperation.class); - Map emptyDataTypes = new HashMap(); - - CacheMangerOperation cacheManager = Mockito.mock(CacheMangerOperation.class); - + @InjectMocks + CsarBusinessLogic csarBusinessLogic ; + Map emptyDataTypes = new HashMap<>(); + List reslist; + private GenericTypeBusinessLogic genericTypeBusinessLogic = Mockito.mock(GenericTypeBusinessLogic.class); + protected ComponentDescriptionValidator componentDescriptionValidator = new ComponentDescriptionValidator(componentsUtils); + protected ComponentProjectCodeValidator componentProjectCodeValidator = new ComponentProjectCodeValidator(componentsUtils); + protected ComponentIconValidator componentIconValidator = new ComponentIconValidator(componentsUtils); + protected ComponentContactIdValidator componentContactIdValidator = new ComponentContactIdValidator(componentsUtils); + protected ComponentTagsValidator componentTagsValidator = new ComponentTagsValidator(componentsUtils); + protected ComponentNameValidator componentNameValidator = new ComponentNameValidator(componentsUtils, toscaOperationFacade); + private ComponentValidator componentValidator = createComponentValidator(); + private SoftwareInformationBusinessLogic softwareInformationBusinessLogic = Mockito.mock(SoftwareInformationBusinessLogic.class); + + private ComponentValidator createComponentValidator() { + List componentFieldValidators = Arrays.asList(componentNameValidator, + componentDescriptionValidator, componentProjectCodeValidator, + componentIconValidator, componentContactIdValidator, + componentTagsValidator); + return new ComponentValidator(componentsUtils,componentFieldValidators); + } + + ResourceBusinessLogic bl; public ResourceBusinessLogicTest() { - } @Before @@ -191,17 +247,10 @@ public class ResourceBusinessLogicTest { MockitoAnnotations.initMocks(this); Mockito.reset(propertyOperation); - ExternalConfiguration.setAppName("catalog-be"); - - // Init Configuration - String appConfigDir = "src/test/resources/config/catalog-be"; - ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), - appConfigDir); - ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); - // Elements mockElementDao = new ElementOperationMock(); + // User data and management user = new User(); user.setUserId("jh0003"); @@ -209,9 +258,9 @@ public class ResourceBusinessLogicTest { user.setLastName("Hendrix"); user.setRole(Role.ADMIN.name()); - Either eitherGetUser = Either.left(user); - when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser); - + when(mockUserAdmin.getUser("jh0003", false)).thenReturn(user); + when(userValidations.validateUserExists(eq(user.getUserId()))).thenReturn(user); + when(userValidations.validateUserNotEmpty(eq(user), anyString())).thenReturn(user); // Servlet Context attributes when(servletContext.getAttribute(Constants.CONFIGURATION_MANAGER_ATTR)).thenReturn(configurationManager); when(servletContext.getAttribute(Constants.WEB_APPLICATION_CONTEXT_WRAPPER_ATTR)) @@ -219,91 +268,125 @@ public class ResourceBusinessLogicTest { when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext); when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao); - Either eitherCountRoot = Either.left(1); Either eitherFalse = Either.left(true); - when(toscaOperationFacade.validateComponentNameExists("Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)) + when(toscaOperationFacade.validateComponentNameExists("tosca.nodes.Root", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)) .thenReturn(eitherFalse); + Either eitherCountExist = Either.left(true); when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist); Either eitherCount = Either.left(false); - when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.VFC, - ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount); - when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.VF, - ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount); - when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, ResourceTypeEnum.PNF, - ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount); - + when(toscaOperationFacade.validateComponentNameExists(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), + eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount); + /* + * when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, + * ResourceTypeEnum.VF, + when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME))); + * ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount); + * when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, + * ResourceTypeEnum.PNF, + * ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount); + * when(toscaOperationFacade.validateComponentNameExists(RESOURCE_NAME, + * ResourceTypeEnum.CR, + * ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount); + */ Either validateDerivedExists = Either.left(true); - when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists); + when(toscaOperationFacade.validateToscaResourceNameExists("tosca.nodes.Root")).thenReturn(validateDerivedExists); Either validateDerivedNotExists = Either.left(false); when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists); - when(graphLockOperation.lockComponent(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Resource))) + when(graphLockOperation.lockComponent(anyString(), eq(NodeTypeEnum.Resource))) .thenReturn(StorageOperationStatus.OK); - when(graphLockOperation.lockComponentByName(Mockito.anyString(), Mockito.eq(NodeTypeEnum.Resource))) + when(graphLockOperation.lockComponentByName(anyString(), eq(NodeTypeEnum.Resource))) .thenReturn(StorageOperationStatus.OK); // createResource resourceResponse = createResourceObject(true); Either eitherCreate = Either.left(resourceResponse); - Either eitherValidate = Either.left(null); - when(toscaOperationFacade.createToscaComponent(Mockito.any(Resource.class))).thenReturn(eitherCreate); - when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate); - Map emptyDataTypes = new HashMap(); + when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate); + when(catalogOperation.updateCatalog(Mockito.any(), Mockito.any())).thenReturn(ActionStatus.OK); + Map emptyDataTypes = new HashMap<>(); when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes)); + when(mockJanusGraphDao.commit()).thenReturn(JanusGraphOperationStatus.OK); // BL object - artifactManager.nodeTemplateOperation = nodeTemplateOperation; - bl = new ResourceBusinessLogic(); + artifactManager.setNodeTemplateOperation(nodeTemplateOperation); + bl = new ResourceBusinessLogic(mockElementDao, groupOperation, groupInstanceOperation, groupTypeOperation, groupBusinessLogic, + interfaceOperation, interfaceLifecycleTypeOperation, artifactManager, componentInstanceBusinessLogic, + resourceImportManager, inputsBusinessLogic, compositionBusinessLogic, resourceDataMergeBusinessLogic, + csarArtifactsAndGroupsBusinessLogic, mergeInstanceUtils, uiComponentDataConverter, csarBusinessLogic, + artifactToscaOperation, propertyBusinessLogic, componentContactIdValidator, componentNameValidator, + componentTagsValidator, componentValidator, componentIconValidator, componentProjectCodeValidator, componentDescriptionValidator); bl.setElementDao(mockElementDao); bl.setUserAdmin(mockUserAdmin); bl.setCapabilityTypeOperation(capabilityTypeOperation); - componentsUtils.Init(); - componentsUtils.setAuditingManager(auditingManager); bl.setComponentsUtils(componentsUtils); bl.setLifecycleManager(lifecycleBl); bl.setGraphLockOperation(graphLockOperation); bl.setArtifactsManager(artifactManager); bl.setPropertyOperation(propertyOperation); - bl.setTitanGenericDao(mockTitanDao); + bl.setJanusGraphDao(mockJanusGraphDao); bl.setApplicationDataTypeCache(applicationDataTypeCache); - bl.setCsarOperation(csarOperation); - bl.setCacheManagerOperation(cacheManager); + bl.setGenericTypeBusinessLogic(genericTypeBusinessLogic); + bl.setCatalogOperations(catalogOperation); toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation); toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation); bl.setToscaOperationFacade(toscaOperationFacade); + bl.setUserValidations(userValidations); + bl.setInterfaceTypeOperation(interfaceTypeOperation); + + csarBusinessLogic.setCsarOperation(csarOperation); Resource resourceCsar = createResourceObjectCsar(true); setCanWorkOnResource(resourceCsar); Either oldResourceRes = Either.left(resourceCsar); - when(toscaOperationFacade.getToscaElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes); + when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes); responseManager = ResponseFormatManager.getInstance(); + bl.setComponentIconValidator(componentIconValidator); + bl.setComponentNameValidator(componentNameValidator); + bl.setComponentDescriptionValidator(componentDescriptionValidator); + bl.setComponentTagsValidator(componentTagsValidator); + bl.setComponentContactIdValidator(componentContactIdValidator); + bl.setComponentProjectCodeValidator(componentProjectCodeValidator); + bl.setComponentValidator(componentValidator); + reslist = new ArrayList(); + reslist.add(resourceResponse); + reslist.add(genericVF); + reslist.add(genericCR); + reslist.add(genericVFC); + reslist.add(genericPNF); + Either, StorageOperationStatus> returneval= Either.left(reslist); + when(toscaOperationFacade.getAllCertifiedResources(true, true)).thenReturn(returneval); + when(toscaOperationFacade.validateComponentNameUniqueness("Resource", ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(Either.left(true)); + Either, StorageOperationStatus> returnevalexception= Either.right(StorageOperationStatus.BAD_REQUEST); + when(toscaOperationFacade.getAllCertifiedResources(false, false)).thenReturn(returnevalexception); } private Resource createResourceObject(boolean afterCreate) { Resource resource = new Resource(); resource.setName(RESOURCE_NAME); + resource.setToscaResourceName(RESOURCE_TOSCA_NAME); resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY); resource.setDescription("My short description"); - List tgs = new ArrayList(); + List tgs = new ArrayList<>(); tgs.add("test"); tgs.add(resource.getName()); resource.setTags(tgs); - List template = new ArrayList(); - template.add("Root"); + List template = new ArrayList<>(); + template.add("tosca.nodes.Root"); resource.setDerivedFrom(template); resource.setVendorName("Motorola"); resource.setVendorRelease("1.0.0"); resource.setContactId("ya5467"); - resource.setIcon("MyIcon"); + resource.setIcon("defaulticon"); if (afterCreate) { resource.setName(resource.getName()); resource.setVersion("0.1"); - resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion()); + resource.setUniqueId(resource.getName() + .toLowerCase() + ":" + resource.getVersion()); resource.setCreatorUserId(user.getUserId()); resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName()); resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); @@ -316,12 +399,12 @@ public class ResourceBusinessLogicTest { resource.setName(RESOURCE_NAME); resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY); resource.setDescription("My short description"); - List tgs = new ArrayList(); + List tgs = new ArrayList<>(); tgs.add("test"); tgs.add(resource.getName()); resource.setTags(tgs); - List template = new ArrayList(); - template.add("Root"); + List template = new ArrayList<>(); + template.add("tosca.nodes.Root"); resource.setDerivedFrom(template); resource.setVendorName("Motorola"); resource.setVendorRelease("1.0.0"); @@ -335,7 +418,8 @@ public class ResourceBusinessLogicTest { resource.setName(resource.getName()); resource.setVersion("0.1"); - resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion()); + resource.setUniqueId(resource.getName() + .toLowerCase() + ":" + resource.getVersion()); resource.setCreatorUserId(user.getUserId()); resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName()); resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); @@ -351,35 +435,40 @@ public class ResourceBusinessLogicTest { @Test public void testHappyScenario() { + validateUserRoles(Role.ADMIN, Role.DESIGNER); Resource resource = createResourceObject(false); - Either createResponse = bl.createResource(resource, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - - if (createResponse.isRight()) { - assertEquals(new Integer(200), createResponse.right().value().getStatus()); + Resource createdResource = null; + try { + createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + assertThat(createResourceObject(true)).isEqualTo(createdResource); + } catch (ComponentException e) { + assertThat(new Integer(200)).isEqualTo(e.getResponseFormat() + .getStatus()); } - assertEquals(createResourceObject(true), createResponse.left().value()); } @Test public void testUpdateHappyScenario() { Resource resource = createResourceObjectCsar(true); setCanWorkOnResource(resource); - + validateUserRoles(Role.ADMIN, Role.DESIGNER); Either resourceLinkedToCsarRes = Either.left(resource); when(toscaOperationFacade.getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, resource.getCsarUUID(), resource.getSystemName())).thenReturn(resourceLinkedToCsarRes); Either validateDerivedExists = Either.left(true); - when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists); - + when(toscaOperationFacade.validateToscaResourceNameExists("tosca.nodes.Root")).thenReturn(validateDerivedExists); + Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); + when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either updateResponse = bl.validateAndUpdateResourceFromCsar(resource, user, null, - null, resource.getUniqueId()); - if (updateResponse.isRight()) { - assertEquals(new Integer(200), updateResponse.right().value().getStatus()); + Resource createdResource = null; + try { + createdResource = bl.validateAndUpdateResourceFromCsar(resource, user, null, null, resource.getUniqueId()); + assertThat(resource.getUniqueId()).isEqualTo(createdResource.getUniqueId()); + } catch (ComponentException e) { + assertThat(new Integer(200)).isEqualTo(e.getResponseFormat() + .getStatus()); } - assertEquals(resource.getUniqueId(), updateResponse.left().value().getUniqueId()); } /* CREATE validations - start ***********************/ @@ -429,21 +518,26 @@ public class ResourceBusinessLogicTest { String resourceName = "alreadyExists"; Resource resourceExist = createResourceObject(false); resourceExist.setName(resourceName); - resourceExist.getTags().add(resourceName); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertResponse(createResponse, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), - resourceName); + resourceExist.getTags() + .add(resourceName); + validateUserRoles(Role.ADMIN, Role.DESIGNER); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, + ComponentTypeEnum.RESOURCE.getValue(), resourceName); + } } private void testResourceNameEmpty() { Resource resourceExist = createResourceObject(false); resourceExist.setName(null); - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertResponse(createResponse, ActionStatus.MISSING_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceNameExceedsLimit() { @@ -452,11 +546,12 @@ public class ResourceBusinessLogicTest { String tooLongResourceName = "zCRCAWjqte0DtgcAAMmcJcXeNubeX1p1vOZNTShAHOYNAHvV3iK"; resourceExccedsNameLimit.setName(tooLongResourceName); - Either createResponse = bl.createResource(resourceExccedsNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), - "" + ValidationUtils.COMPONENT_NAME_MAX_LENGTH); + try { + bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT, + ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_NAME_MAX_LENGTH); + } } private void testResourceNameWrongFormat() { @@ -465,10 +560,11 @@ public class ResourceBusinessLogicTest { String nameWrongFormat = "ljg?fd"; resource.setName(nameWrongFormat); - Either createResponse = bl.createResource(resource, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue()); + } } // Resource name - end @@ -486,12 +582,12 @@ public class ResourceBusinessLogicTest { + "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs"; resourceExccedsDescLimit.setDescription(tooLongResourceDesc); - - Either createResponse = bl.createResource(resourceExccedsDescLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, - ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH); + try { + bl.createResource(resourceExccedsDescLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, + ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH); + } } private void testResourceDescNotEnglish() { @@ -500,35 +596,36 @@ public class ResourceBusinessLogicTest { String notEnglishDesc = "\uC2B5"; notEnglish.setDescription(notEnglishDesc); - Either createResponse = bl.createResource(notEnglish, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_DESCRIPTION, - ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(notEnglish, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_DESCRIPTION, + ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceDescriptionEmpty() { Resource resourceExist = createResourceObject(false); resourceExist.setDescription(""); - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_DESCRIPTION, - ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, + ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceDescriptionMissing() { Resource resourceExist = createResourceObject(false); resourceExist.setDescription(null); - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_DESCRIPTION, - ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_DESCRIPTION, + ComponentTypeEnum.RESOURCE.getValue()); + } } // Resource description - end // Resource icon start @@ -537,34 +634,33 @@ public class ResourceBusinessLogicTest { Resource resourceExist = createResourceObject(false); resourceExist.setIcon(null); - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_ICON, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_ICON, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceIconInvalid() { Resource resourceExist = createResourceObject(false); resourceExist.setIcon("kjk3453^&"); - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceIconExceedsLimit() { Resource resourceExist = createResourceObject(false); resourceExist.setIcon("dsjfhskdfhskjdhfskjdhkjdhfkshdfksjsdkfhsdfsdfsdfsfsdfsf"); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), - "" + ValidationUtils.ICON_MAX_LENGTH); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT, + ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.ICON_MAX_LENGTH); + } } // Resource icon end @@ -572,23 +668,21 @@ public class ResourceBusinessLogicTest { private void testResourceTagNotExist() { Resource resourceExist = createResourceObject(false); resourceExist.setTags(null); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_TAGS); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS); + } } private void testResourceTagEmpty() { Resource resourceExist = createResourceObject(false); - resourceExist.setTags(new ArrayList()); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_TAGS); + resourceExist.setTags(new ArrayList<>()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_TAGS); + } } private void testTagsExceedsLimitCreate() { @@ -615,7 +709,7 @@ public class ResourceBusinessLogicTest { String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5"; String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0"; - List tagsList = new ArrayList(); + List tagsList = new ArrayList<>(); tagsList.add(tag1); tagsList.add(tag2); tagsList.add(tag3); @@ -640,59 +734,55 @@ public class ResourceBusinessLogicTest { tagsList.add(resourceExccedsNameLimit.getName()); resourceExccedsNameLimit.setTags(tagsList); - - Either createResponse = bl.createResource(resourceExccedsNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, - "" + ValidationUtils.TAG_LIST_MAX_LENGTH); - + try { + bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, + "" + ValidationUtils.TAG_LIST_MAX_LENGTH); + } } private void testTagsSingleExceedsLimit() { Resource resourceExccedsNameLimit = createResourceObject(false); String tag1 = "afzs2qLBb5X6tZhiunkcEwiFX1qRQY8YZl3y3Du5M5xeQY5Nq9afcFHDZ9HaURw43gH27nAUWM36bMbMylwTFSzzNV8NO4v4ripe6Q15Vc2nPOFI"; String tag2 = resourceExccedsNameLimit.getName(); - List tagsList = new ArrayList(); + List tagsList = new ArrayList<>(); tagsList.add(tag1); tagsList.add(tag2); resourceExccedsNameLimit.setTags(tagsList); - - Either createResponse = bl.createResource(resourceExccedsNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT, - "" + ValidationUtils.TAG_MAX_LENGTH); - + try { + bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT, + "" + ValidationUtils.TAG_MAX_LENGTH); + } } private void testTagsNoServiceName() { Resource serviceExccedsNameLimit = createResourceObject(false); String tag1 = "afzs2qLBb"; - List tagsList = new ArrayList(); + List tagsList = new ArrayList<>(); tagsList.add(tag1); serviceExccedsNameLimit.setTags(tagsList); - - Either createResponse = bl.createResource(serviceExccedsNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME); - + try { + bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME); + } } private void testInvalidTag() { Resource serviceExccedsNameLimit = createResourceObject(false); String tag1 = "afzs2qLBb%#%"; - List tagsList = new ArrayList(); + List tagsList = new ArrayList<>(); tagsList.add(tag1); serviceExccedsNameLimit.setTags(tagsList); - - Either createResponse = bl.createResource(serviceExccedsNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_FIELD_FORMAT, new String[] { "Resource", "tag" }); - + try { + bl.createResource(serviceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_FIELD_FORMAT, new String[] { "Resource", "tag" }); + } } // Resource tags - stop @@ -704,10 +794,11 @@ public class ResourceBusinessLogicTest { String contactIdTooLong = "thisNameIsVeryLongAndExeccedsTheNormalLengthForContactId"; resourceContactId.setContactId(contactIdTooLong); - Either createResponse = bl.createResource(resourceContactId, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testContactIdWrongFormatCreate() { @@ -715,57 +806,56 @@ public class ResourceBusinessLogicTest { // 3 letters and 3 digits and special characters String contactIdFormatWrong = "yrt134!!!"; resourceContactId.setContactId(contactIdFormatWrong); - - Either createResponse = bl.createResource(resourceContactId, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceContactId, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceContactIdEmpty() { Resource resourceExist = createResourceObject(false); resourceExist.setContactId(""); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceContactIdMissing() { Resource resourceExist = createResourceObject(false); resourceExist.setContactId(null); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testVendorNameExceedsLimit() { Resource resourceExccedsVendorNameLimit = createResourceObject(false); String tooLongVendorName = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E"; resourceExccedsVendorNameLimit.setVendorName(tooLongVendorName); - - Either createResponse = bl.createResource(resourceExccedsVendorNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT, - "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH); + try { + bl.createResource(resourceExccedsVendorNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.VENDOR_NAME_EXCEEDS_LIMIT, + "" + ValidationUtils.VENDOR_NAME_MAX_LENGTH); + } } private void testResourceVendorModelNumberExceedsLimit() { Resource resourceExccedsVendorModelNumberLimit = createResourceObject(false); String tooLongVendorModelNumber = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E"; resourceExccedsVendorModelNumberLimit.setResourceVendorModelNumber(tooLongVendorModelNumber); - - Either createResponse = bl.createResource(resourceExccedsVendorModelNumberLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT, - "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH); + try { + bl.createResource(resourceExccedsVendorModelNumberLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, + null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.RESOURCE_VENDOR_MODEL_NUMBER_EXCEEDS_LIMIT, + "" + ValidationUtils.RESOURCE_VENDOR_MODEL_NUMBER_MAX_LENGTH); + } } private void testVendorNameWrongFormatCreate() { @@ -773,58 +863,55 @@ public class ResourceBusinessLogicTest { // contains * String nameWrongFormat = "ljg*fd"; resource.setVendorName(nameWrongFormat); - - Either createResponse = bl.createResource(resource, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_VENDOR_NAME); + try { + bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME, nameWrongFormat); + } } private void testVendorReleaseWrongFormat() { Resource resource = createResourceObject(false); // contains > - String nameWrongFormat = "1>2"; - resource.setVendorRelease(nameWrongFormat); - - Either createResponse = bl.createResource(resource, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_VENDOR_RELEASE); - + String vendorReleaseWrongFormat = "1>2"; + resource.setVendorRelease(vendorReleaseWrongFormat); + try { + bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_VENDOR_RELEASE, vendorReleaseWrongFormat); + } } private void testVendorReleaseExceedsLimitCreate() { Resource resourceExccedsNameLimit = createResourceObject(false); String tooLongVendorRelease = "h1KSyJh9Eh1KSyJh9Eh1KSyJh9Eh1KSyJh9E"; resourceExccedsNameLimit.setVendorRelease(tooLongVendorRelease); - - Either createResponse = bl.createResource(resourceExccedsNameLimit, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, - "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH); + try { + bl.createResource(resourceExccedsNameLimit, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, + "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH); + } } private void testResourceVendorNameMissing() { Resource resourceExist = createResourceObject(false); resourceExist.setVendorName(null); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.MISSING_VENDOR_NAME); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_VENDOR_NAME); + } } private void testResourceVendorReleaseMissing() { Resource resourceExist = createResourceObject(false); resourceExist.setVendorRelease(null); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.MISSING_VENDOR_RELEASE); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_VENDOR_RELEASE); + } } // Resource vendor name/release stop @@ -832,12 +919,11 @@ public class ResourceBusinessLogicTest { private void testResourceCategoryExist() { Resource resourceExist = createResourceObject(false); resourceExist.setCategories(null); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_MISSING_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); + } } private void testResourceBadCategoryCreate() { @@ -845,12 +931,11 @@ public class ResourceBusinessLogicTest { Resource resourceExist = createResourceObject(false); resourceExist.setCategories(null); resourceExist.addCategory("koko", "koko"); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); + } } // Category stop @@ -860,21 +945,23 @@ public class ResourceBusinessLogicTest { Resource createResourceObjectAfterCreate = createResourceObject(true); // Adding cost and licenseType to basic mock Either eitherCreate = Either.left(createResourceObjectAfterCreate); - when(toscaOperationFacade.createToscaComponent(Mockito.any(Resource.class))).thenReturn(eitherCreate); + when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate); String cost = "123.456"; String licenseType = "User"; createResourceObject.setCost(cost); createResourceObject.setLicenseType(licenseType); - Either createResponse = bl.createResource(createResourceObject, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - - if (createResponse.isRight()) { - assertEquals(new Integer(200), createResponse.right().value().getStatus()); + Resource createdResource; + try { + createdResource = bl.createResource(createResourceObject, AuditingActionEnum.CREATE_RESOURCE, user, null, + null); + createResourceObjectAfterCreate.setCost(cost); + createResourceObjectAfterCreate.setLicenseType(licenseType); + assertThat(createResourceObjectAfterCreate).isEqualTo(createdResource); + } catch (ComponentException e) { + assertThat(new Integer(200)).isEqualTo(e.getResponseFormat() + .getStatus()); } - createResourceObjectAfterCreate.setCost(cost); - createResourceObjectAfterCreate.setLicenseType(licenseType); - assertEquals(createResourceObjectAfterCreate, createResponse.left().value()); } private void testCostWrongFormatCreate() { @@ -882,11 +969,11 @@ public class ResourceBusinessLogicTest { // Comma instead of fullstop String cost = "12356,464"; resourceCost.setCost(cost); - - Either createResponse = bl.createResource(resourceCost, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_CONTENT); + try { + bl.createResource(resourceCost, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_CONTENT); + } } // Cost stop @@ -896,11 +983,11 @@ public class ResourceBusinessLogicTest { // lowcase String licenseType = "cpu"; resourceLicenseType.setLicenseType(licenseType); - - Either createResponse = bl.createResource(resourceLicenseType, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_CONTENT); + try { + bl.createResource(resourceLicenseType, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_CONTENT); + } } // License type stop @@ -909,54 +996,60 @@ public class ResourceBusinessLogicTest { Resource resourceExist = createResourceObject(false); List list = null; resourceExist.setDerivedFrom(list); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + } } private void testResourceTemplateEmpty() { Resource resourceExist = createResourceObject(false); - resourceExist.setDerivedFrom(new ArrayList()); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + resourceExist.setDerivedFrom(new ArrayList<>()); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + } } private void testResourceTemplateInvalid() { Resource resourceExist = createResourceObject(false); - ArrayList derivedFrom = new ArrayList(); + ArrayList derivedFrom = new ArrayList<>(); derivedFrom.add("kuku"); resourceExist.setDerivedFrom(derivedFrom); + try { + bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND); + } + } - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isRight()); + // Derived from stop + private void assertComponentException(ComponentException e, ActionStatus expectedStatus, String... variables) { + ResponseFormat actualResponse = e.getResponseFormat() != null ? e.getResponseFormat() + : componentsUtils.getResponseFormat(e.getActionStatus(), e.getParams()); + assertResponse(actualResponse, expectedStatus, variables); + } - assertResponse(createResponse, ActionStatus.PARENT_RESOURCE_NOT_FOUND); + private void assertResponse(ResponseFormat actualResponse, ActionStatus expectedStatus, String... variables) { + ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables); + assertThat(expectedResponse.getStatus()).isEqualTo(actualResponse.getStatus()); + assertThat(expectedResponse.getFormattedMessage()).isEqualTo(actualResponse.getFormattedMessage()); } - // Derived from stop private void assertResponse(Either createResponse, ActionStatus expectedStatus, String... variables) { - ResponseFormat expectedResponse = responseManager.getResponseFormat(expectedStatus, variables); - ResponseFormat actualResponse = createResponse.right().value(); - assertEquals(expectedResponse.getStatus(), actualResponse.getStatus()); - assertEquals("assert error description", expectedResponse.getFormattedMessage(), - actualResponse.getFormattedMessage()); + assertResponse(createResponse.right() + .value(), expectedStatus, variables); } - // UPDATE tests - start - // Resource name - @Test - public void testResourceNameWrongFormat_UPDATE() { - Resource resource = createResourceObject(true); - Resource updatedResource = createResourceObject(true); + // UPDATE tests - start + // Resource name + @Test + public void testResourceNameWrongFormat_UPDATE() { + Resource resource = createResourceObject(true); + Resource updatedResource = createResourceObject(true); // this is in order to prevent failing with 403 earlier Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); @@ -967,18 +1060,17 @@ public class ResourceBusinessLogicTest { Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue()); - + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_COMPONENT_NAME, ComponentTypeEnum.RESOURCE.getValue()); + } } - @Test - public void testResourceNameAfterCertify_UPDATE() { - Resource resource = createResourceObject(true); - Resource updatedResource = createResourceObject(true); + @Test + public void testResourceNameAfterCertify_UPDATE() { + Resource resource = createResourceObject(true); + Resource updatedResource = createResourceObject(true); // this is in order to prevent failing with 403 earlier Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); @@ -991,40 +1083,17 @@ public class ResourceBusinessLogicTest { Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED); - - } - - @Ignore - public void testResourceNameExceedsLimit_UPDATE() { - Resource resource = createResourceObject(true); - Resource updatedResource = createResourceObject(true); - - // this is in order to prevent failing with 403 earlier - Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); - when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); - - // 51 chars, the limit is 50 - String tooLongResourceName = "zCRCAWjqte0DtgcAAMmcJcXeNubeX1p1vOZNTShAHOYNAHvV3iK"; - updatedResource.setName(tooLongResourceName); - Either dataModelResponse = Either.left(resource); - when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT, ComponentTypeEnum.RESOURCE.getValue(), - "" + ValidationUtils.COMPONENT_NAME_MAX_LENGTH); + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.RESOURCE_NAME_CANNOT_BE_CHANGED); + } } - @Test - public void testResourceNameAlreadyExist_UPDATE() { - Resource resource = createResourceObject(true); - Resource updatedResource = createResourceObject(true); + @Test + public void testResourceNameAlreadyExist_UPDATE() { + Resource resource = createResourceObject(true); + Resource updatedResource = createResourceObject(true); // this is in order to prevent failing with 403 earlier Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); @@ -1034,11 +1103,12 @@ public class ResourceBusinessLogicTest { updatedResource.setName(resourceName); Either dataModelResponse = Either.left(updatedResource); when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, ComponentTypeEnum.RESOURCE.getValue(), - resourceName); + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_NAME_ALREADY_EXIST, + ComponentTypeEnum.RESOURCE.getValue(), resourceName); + } } // @@ -1064,12 +1134,12 @@ public class ResourceBusinessLogicTest { updatedResource.setDescription(tooLongResourceDesc); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, - ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH); - + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT, + ComponentTypeEnum.RESOURCE.getValue(), "" + ValidationUtils.COMPONENT_DESCRIPTION_MAX_LENGTH); + } } @Test @@ -1086,12 +1156,11 @@ public class ResourceBusinessLogicTest { updatedResource.setIcon(icon); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue()); - + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_ICON, ComponentTypeEnum.RESOURCE.getValue()); + } } @Test @@ -1111,11 +1180,11 @@ public class ResourceBusinessLogicTest { ; Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED); - + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.RESOURCE_ICON_CANNOT_BE_CHANGED); + } } @Test @@ -1149,7 +1218,7 @@ public class ResourceBusinessLogicTest { String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5"; String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0"; - List tagsList = new ArrayList(); + List tagsList = new ArrayList<>(); tagsList.add(tag1); tagsList.add(tag2); tagsList.add(tag3); @@ -1176,12 +1245,12 @@ public class ResourceBusinessLogicTest { updatedResource.setTags(tagsList); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, - "" + ValidationUtils.TAG_LIST_MAX_LENGTH); + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_TAGS_EXCEED_LIMIT, + "" + ValidationUtils.TAG_LIST_MAX_LENGTH); + } } @Test @@ -1198,15 +1267,15 @@ public class ResourceBusinessLogicTest { updatedResource.setVendorName(nameWrongFormat); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.INVALID_VENDOR_NAME); - + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME, nameWrongFormat); + } } @Test - public void testVendorNameAfterCertify_UPDATE() { + public void testVendorNameWrongFormat() { Resource resource = createResourceObject(true); Resource updatedResource = createResourceObject(true); @@ -1221,11 +1290,11 @@ public class ResourceBusinessLogicTest { ; Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.RESOURCE_VENDOR_NAME_CANNOT_BE_CHANGED); - + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.INVALID_VENDOR_NAME, nameWrongFormat); + } } @Test @@ -1241,33 +1310,12 @@ public class ResourceBusinessLogicTest { updatedResource.setVendorRelease(tooLongVendorRelease); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resource.getUniqueId(), - updatedResource, null, user, false); - assertTrue(createResponse.isRight()); - assertResponse(createResponse, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, - "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH); - } - - @Ignore - public void testContactIdWrongFormat_UPDATE() { - Resource resource = createResourceObject(true); - Resource updatedResource = createResourceObject(true); - - // this is in order to prevent failing with 403 earlier - Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); - when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); - - String resourceId = resource.getUniqueId(); - // 3 letters and 3 digits - String contactIdTooLong = "yrt134"; - updatedResource.setContactId(contactIdTooLong); - Either dataModelResponse = Either.left(resource); - when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_CONTACT, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.updateResourceMetadata(resource.getUniqueId(), updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.VENDOR_RELEASE_EXCEEDS_LIMIT, + "" + ValidationUtils.VENDOR_RELEASE_MAX_LENGTH); + } } @Test @@ -1285,11 +1333,11 @@ public class ResourceBusinessLogicTest { updatedResource.addCategory(badCategory, "fikt"); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); + try { + bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.COMPONENT_INVALID_CATEGORY, ComponentTypeEnum.RESOURCE.getValue()); + } } @Test @@ -1307,12 +1355,12 @@ public class ResourceBusinessLogicTest { resource.setVersion("1.0"); ; Either dataModelResponse = Either.left(resource); - when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED); + when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse); + try { + bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.RESOURCE_CATEGORY_CANNOT_BE_CHANGED); + } } // Derived from start @@ -1330,11 +1378,11 @@ public class ResourceBusinessLogicTest { updatedResource.setDerivedFrom(list); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + try { + bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + } } @Test @@ -1347,14 +1395,14 @@ public class ResourceBusinessLogicTest { Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); - updatedResource.setDerivedFrom(new ArrayList()); + updatedResource.setDerivedFrom(new ArrayList<>()); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + try { + bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.MISSING_DERIVED_FROM_TEMPLATE); + } } @Test @@ -1367,16 +1415,16 @@ public class ResourceBusinessLogicTest { Either eitherUpdate = Either.left(setCanWorkOnResource(resource)); when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); - ArrayList derivedFrom = new ArrayList(); + ArrayList derivedFrom = new ArrayList<>(); derivedFrom.add("kuku"); updatedResource.setDerivedFrom(derivedFrom); Either dataModelResponse = Either.left(resource); when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); - - assertResponse(createResponse, ActionStatus.PARENT_RESOURCE_NOT_FOUND); + try { + bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.PARENT_RESOURCE_NOT_FOUND); + } } @Test @@ -1390,24 +1438,23 @@ public class ResourceBusinessLogicTest { when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); Either isToscaNameExtending = Either.left(true); - when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString())) + when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString())) .thenReturn(isToscaNameExtending); Either, StorageOperationStatus> findPropertiesOfNode = Either .left(new HashMap<>()); - when(propertyOperation.deleteAllPropertiesAssociatedToNode(Mockito.any(NodeTypeEnum.class), - Mockito.anyString())).thenReturn(findPropertiesOfNode); + when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), anyString())) + .thenReturn(findPropertiesOfNode); resource.setVersion("1.0"); - ArrayList derivedFrom = new ArrayList(); + ArrayList derivedFrom = new ArrayList<>(); derivedFrom.add("tosca.nodes.Root"); updatedResource.setDerivedFrom(derivedFrom); Either dataModelResponse = Either.left(updatedResource); when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isLeft()); + Resource createdResource = bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + assertThat(createdResource).isNotNull(); } @Test @@ -1421,85 +1468,93 @@ public class ResourceBusinessLogicTest { when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate); Either isToscaNameExtending = Either.left(false); - when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString())) + when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString())) .thenReturn(isToscaNameExtending); resource.setVersion("1.0"); - ArrayList derivedFrom = new ArrayList(); + ArrayList derivedFrom = new ArrayList<>(); derivedFrom.add("tosca.nodes.Root"); updatedResource.setDerivedFrom(derivedFrom); Either dataModelResponse = Either.left(resource); - when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse); - Either createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null, - user, false); - assertTrue(createResponse.isRight()); + when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse); + Either, StorageOperationStatus> findPropertiesOfNode = Either + .left(new HashMap<>()); + when(propertyOperation.deleteAllPropertiesAssociatedToNode(any(NodeTypeEnum.class), anyString())) + .thenReturn(findPropertiesOfNode); - assertResponse(createResponse, ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND); + try { + bl.updateResourceMetadata(resourceId, updatedResource, null, user, false); + } catch (ComponentException e) { + assertComponentException(e, ActionStatus.PARENT_RESOURCE_DOES_NOT_EXTEND); + } } // Derived from stop @Test public void createOrUpdateResourceAlreadyCheckout() { + createRoot(); Resource resourceExist = createResourceObject(false); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - - createResponse.left().value().setLastUpdaterUserId(user.getUserId()); - assertTrue(createResponse.isLeft()); - - Either getLatestResult = Either.left(createResponse.left().value()); - when(toscaOperationFacade.getLatestByName(resourceExist.getName())).thenReturn(getLatestResult); - when(toscaOperationFacade.overrideComponent(Mockito.any(Component.class), Mockito.any(Component.class))) + validateUserRoles(Role.ADMIN, Role.DESIGNER); + Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, + null); + createdResource.setLastUpdaterUserId(user.getUserId()); + assertThat(createdResource).isNotNull(); + Either getLatestResult = Either.left(createdResource); + Either getCompLatestResult = Either.left(createdResource); + when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())) + .thenReturn(getCompLatestResult); + when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))) .thenReturn(getLatestResult); Resource resourceToUpdtae = createResourceObject(false); - Either, ResponseFormat> createOrUpdateResource = bl - .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null); - assertTrue(createOrUpdateResource.isLeft()); + ImmutablePair createOrUpdateResource = bl + .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false); + assertNotNull(createOrUpdateResource); - Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(Mockito.any(Resource.class), - Mockito.any(Resource.class)); - Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), Mockito.eq(user), - Mockito.eq(LifeCycleTransitionEnum.CHECKOUT), Mockito.any(LifecycleChangeInfoWithAction.class), - Mockito.anyBoolean(), Mockito.anyBoolean()); + Mockito.verify(toscaOperationFacade, Mockito.times(1)) + .overrideComponent(any(Resource.class), any(Resource.class)); + Mockito.verify(lifecycleBl, Mockito.times(0)) + .changeState(anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), + any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean()); } @Test public void createOrUpdateResourceCertified() { + createRoot(); Resource resourceExist = createResourceObject(false); - - Either createResponse = bl.createResource(resourceExist, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - - assertTrue(createResponse.isLeft()); - Resource certifiedResource = createResponse.left().value(); - certifiedResource.setLifecycleState(LifecycleStateEnum.CERTIFIED); - certifiedResource.setVersion("1.0"); - - Either getLatestResult = Either.left(certifiedResource); - when(toscaOperationFacade.getLatestByName(resourceExist.getName())).thenReturn(getLatestResult); - when(toscaOperationFacade.overrideComponent(Mockito.any(Component.class), Mockito.any(Component.class))) + validateUserRoles(Role.ADMIN, Role.DESIGNER); + Resource createdResource = bl.createResource(resourceExist, AuditingActionEnum.CREATE_RESOURCE, user, null, + null); + + assertThat(createdResource).isNotNull(); + createdResource.setLifecycleState(LifecycleStateEnum.CERTIFIED); + createdResource.setVersion("1.0"); + + Either getLatestResult = Either.left(createdResource); + Either getCompLatestResult = Either.left(createdResource); + when(toscaOperationFacade.getLatestByToscaResourceName(resourceExist.getToscaResourceName())) + .thenReturn(getCompLatestResult); + when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))) .thenReturn(getLatestResult); - when(lifecycleBl.changeState(Mockito.anyString(), Mockito.eq(user), - Mockito.eq(LifeCycleTransitionEnum.CHECKOUT), Mockito.any(LifecycleChangeInfoWithAction.class), - Mockito.anyBoolean(), Mockito.anyBoolean())).thenReturn(createResponse); + when(lifecycleBl.changeState(anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), + any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean())) + .thenReturn(Either.left(createdResource)); Resource resourceToUpdtae = createResourceObject(false); - Either, ResponseFormat> createOrUpdateResource = bl - .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null); - assertTrue(createOrUpdateResource.isLeft()); + ImmutablePair createOrUpdateResource = bl + .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false); + assertNotNull(createOrUpdateResource); - Mockito.verify(toscaOperationFacade, Mockito.times(1)).overrideComponent(Mockito.any(Component.class), - Mockito.any(Component.class)); - Mockito.verify(lifecycleBl, Mockito.times(1)).changeState(Mockito.anyString(), Mockito.eq(user), - Mockito.eq(LifeCycleTransitionEnum.CHECKOUT), Mockito.any(LifecycleChangeInfoWithAction.class), - Mockito.anyBoolean(), Mockito.anyBoolean()); + Mockito.verify(toscaOperationFacade, Mockito.times(1)) + .overrideComponent(any(Resource.class), any(Resource.class)); + Mockito.verify(lifecycleBl, Mockito.times(1)) + .changeState(anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), + any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean()); } @@ -1515,24 +1570,99 @@ public class ResourceBusinessLogicTest { when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdtae.getToscaResourceName())) .thenReturn(getLatestToscaNameResult); - Either, ResponseFormat> createOrUpdateResource = bl - .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null); - assertTrue(createOrUpdateResource.isLeft()); - - Mockito.verify(toscaOperationFacade, Mockito.times(0)).overrideComponent(Mockito.any(Component.class), - Mockito.any(Component.class)); - Mockito.verify(lifecycleBl, Mockito.times(0)).changeState(Mockito.anyString(), Mockito.eq(user), - Mockito.eq(LifeCycleTransitionEnum.CHECKOUT), Mockito.any(LifecycleChangeInfoWithAction.class), - Mockito.anyBoolean(), Mockito.anyBoolean()); - + ImmutablePair createOrUpdateResource = bl + .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null, null, false); + assertThat(createOrUpdateResource).isNotNull(); + + Mockito.verify(toscaOperationFacade, times(1)) + .createToscaComponent(eq(resourceToUpdtae)); + Mockito.verify(toscaOperationFacade, Mockito.times(0)) + .overrideComponent(any(Resource.class), any(Resource.class)); + Mockito.verify(lifecycleBl, Mockito.times(0)) + .changeState(anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), + any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean()); + + } + + @Test + public void testIfNodeTypeNameHasValidPrefix() { + final List definedNodeTypeNamespaceList = ConfigurationManager.getConfigurationManager() + .getConfiguration().getDefinedResourceNamespace(); + + definedNodeTypeNamespaceList.parallelStream().forEach(validNodeTypePrefix -> { + final String nodeName = validNodeTypePrefix + "." + "abc"; + final Optional result = bl.validateNodeTypeNamePrefix(nodeName, definedNodeTypeNamespaceList); + assertTrue(result.isPresent()); + }); + } + + @Test + public void updateNestedResource_typeIsNew() throws IOException { + Resource resourceToUpdate = createResourceObject(false); + String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc"; + String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml"); + CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(), RESOURCE_NAME, "template name", jsonContent, + true); + String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType() + .name(), csarInfo.getVfResourceName(), nodeName) + .getRight(); + when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + + ImmutablePair createOrUpdateResource = bl + .createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo, nodeName, false); + assertThat(createOrUpdateResource).isNotNull(); + + Mockito.verify(toscaOperationFacade, times(1)) + .createToscaComponent(eq(resourceToUpdate)); + Mockito.verify(toscaOperationFacade, times(0)) + .overrideComponent(any(Resource.class), any(Resource.class)); + Mockito.verify(lifecycleBl, times(0)) + .changeState(anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), + any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean()); + } + + @Test + public void updateNestedResource_typeExists() throws IOException { + createRoot(); + Resource resourceToUpdate = createResourceObject(false); + setCanWorkOnResource(resourceResponse); + String nodeName = Constants.USER_DEFINED_RESOURCE_NAMESPACE_PREFIX + "." + "abc"; + String jsonContent = ImportUtilsTest.loadFileNameToJsonString("normative-types-new-webServer.yml"); + CsarInfo csarInfo = new CsarInfo(user, "abcd1234", new HashMap<>(), RESOURCE_NAME, "template name", jsonContent, + true); + String nestedResourceName = bl.buildNestedToscaResourceName(resourceToUpdate.getResourceType() + .name(), csarInfo.getVfResourceName(), nodeName) + .getRight(); + when(toscaOperationFacade.getLatestByName(resourceToUpdate.getName())) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdate.getToscaResourceName())) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + when(toscaOperationFacade.getLatestByToscaResourceName(nestedResourceName)) + .thenReturn(Either.left(resourceResponse)); + when(toscaOperationFacade.overrideComponent(any(Resource.class), any(Resource.class))) + .thenReturn(Either.left(resourceResponse)); + + ImmutablePair createOrUpdateResource = bl + .createOrUpdateResourceByImport(resourceToUpdate, user, false, false, false, csarInfo, nodeName, false); + assertThat(createOrUpdateResource).isNotNull(); + Mockito.verify(toscaOperationFacade, times(1)) + .overrideComponent(any(Resource.class), any(Resource.class)); + Mockito.verify(lifecycleBl, times(0)) + .changeState(anyString(), eq(user), eq(LifeCycleTransitionEnum.CHECKOUT), + any(LifecycleChangeInfoWithAction.class), Mockito.anyBoolean(), Mockito.anyBoolean()); } @Test public void testValidatePropertiesDefaultValues_SuccessfullWithoutProperties() { Resource basic = createResourceObject(true); - Either validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic); - assertTrue(validatePropertiesDefaultValues.isLeft()); + Boolean validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic); + assertTrue(validatePropertiesDefaultValues); } @Test @@ -1547,11 +1677,11 @@ public class ResourceBusinessLogicTest { basic.setProperties(properties); when(propertyOperation.isPropertyTypeValid(property)).thenReturn(true); when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(true); - Either validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic); - assertTrue(validatePropertiesDefaultValues.isLeft()); + Boolean validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic); + assertTrue(validatePropertiesDefaultValues); } - @Test + @Test(expected = ComponentException.class) public void testValidatePropertiesDefaultValues_FailedWithProperties() { Resource basic = createResourceObject(true); PropertyDefinition property = new PropertyDefinition(); @@ -1563,8 +1693,7 @@ public class ResourceBusinessLogicTest { basic.setProperties(properties); when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(false); - Either validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic); - assertTrue(validatePropertiesDefaultValues.isRight()); + bl.validatePropertiesDefaultValues(basic); } // @Test @@ -1630,7 +1759,6 @@ public class ResourceBusinessLogicTest { // Mockito.times(1)).deleteAllComponentArtifactsIfNotOnGraph(artifacts); // } - @SuppressWarnings("unchecked") @Test public void testFindVfCsarArtifactsToHandle() { @@ -1644,6 +1772,7 @@ public class ResourceBusinessLogicTest { String artifactInfoToUpdateFileName = "infoArtifactToUpdate.yaml"; String artifactInfoToDeleteFileName = "infoArtifactToDelete.yaml"; + String artifactInfoToNotDeleteFileName = "infoArtifactNotToDelete.yaml"; String artifactInfoToCreateFileName = "infoArtifactToCreate.yaml"; byte[] oldPayloadData = "oldPayloadData".getBytes(); @@ -1689,11 +1818,22 @@ public class ResourceBusinessLogicTest { artifactToDelete.setArtifactType("SNMP_TRAP"); artifactToDelete.setPayload(oldPayloadData); artifactToDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData)); + artifactToDelete.setIsFromCsar(true); + + ArtifactDefinition artifactToNotDelete = new ArtifactDefinition(); + artifactToNotDelete.setMandatory(false); + artifactToNotDelete.setArtifactName(artifactInfoToNotDeleteFileName); + artifactToNotDelete.setArtifactType("SNMP_TRAP"); + artifactToNotDelete.setPayload(oldPayloadData); + artifactToNotDelete.setArtifactChecksum(GeneralUtility.calculateMD5Base64EncodedByByteArray(oldPayloadData)); + artifactToNotDelete.setIsFromCsar(false); ArtifactDefinition artifactToIgnore = new ArtifactDefinition(); artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToUpdate.getArtifactName()), artifactToUpdate); artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToDelete.getArtifactName()), artifactToDelete); + artifacts.put(ValidationUtils.normalizeArtifactLabel(artifactToNotDelete.getArtifactName()), + artifactToNotDelete); artifacts.put("ignore", artifactToIgnore); resource.setDeploymentArtifacts(deploymentArtifacts); @@ -1703,24 +1843,34 @@ public class ResourceBusinessLogicTest { NonMetaArtifactInfo deploymentArtifactInfoToUpdate = new NonMetaArtifactInfo( deploymentArtifactToUpdate.getArtifactName(), null, ArtifactTypeEnum.findType(deploymentArtifactToUpdate.getArtifactType()), - ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, deploymentArtifactToUpdate.getArtifactName()); + ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, deploymentArtifactToUpdate.getArtifactName(), false); NonMetaArtifactInfo informationalArtifactInfoToUpdate = new NonMetaArtifactInfo( artifactToUpdate.getArtifactName(), null, ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), - ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, artifactToUpdate.getArtifactName()); + ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, artifactToUpdate.getArtifactName(), false); + + NonMetaArtifactInfo informationalArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo( + artifactToUpdate.getArtifactName(), null, ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), + ArtifactGroupTypeEnum.INFORMATIONAL, newPayloadData, artifactToUpdate.getArtifactName(), true); + + NonMetaArtifactInfo deploymentArtifactInfoToUpdateFromCsar = new NonMetaArtifactInfo( + artifactToUpdate.getArtifactName(), null, ArtifactTypeEnum.findType(artifactToUpdate.getArtifactType()), + ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, artifactToUpdate.getArtifactName(), true); NonMetaArtifactInfo deploymentArtifactInfoToCreate = new NonMetaArtifactInfo(deploymentArtifactToCreateFileName, null, ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, - deploymentArtifactToCreateFileName); + deploymentArtifactToCreateFileName, false); NonMetaArtifactInfo informationalArtifactInfoToCreate = new NonMetaArtifactInfo(artifactInfoToCreateFileName, - null, ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.DEPLOYMENT, newPayloadData, - artifactInfoToCreateFileName); + null, ArtifactTypeEnum.OTHER, ArtifactGroupTypeEnum.INFORMATIONAL, newPayloadData, + artifactInfoToCreateFileName, false); artifactPathAndNameList.add(deploymentArtifactInfoToUpdate); artifactPathAndNameList.add(informationalArtifactInfoToUpdate); artifactPathAndNameList.add(deploymentArtifactInfoToCreate); artifactPathAndNameList.add(informationalArtifactInfoToCreate); + artifactPathAndNameList.add(informationalArtifactInfoToUpdateFromCsar); + artifactPathAndNameList.add(deploymentArtifactInfoToUpdateFromCsar); Object[] argObjects = { resource, artifactPathAndNameList, user }; Class[] argClasses = { Resource.class, List.class, User.class }; @@ -1731,99 +1881,49 @@ public class ResourceBusinessLogicTest { .invoke(bl, argObjects); assertTrue(findVfCsarArtifactsToHandleRes.isLeft()); EnumMap> foundVfArtifacts = findVfCsarArtifactsToHandleRes - .left().value(); - assertTrue(foundVfArtifacts.get(ArtifactOperationEnum.Create).size() == 2); - assertTrue(foundVfArtifacts.get(ArtifactOperationEnum.Update).size() == 2); - assertTrue(foundVfArtifacts.get(ArtifactOperationEnum.Create).size() == 2); - - } catch (Exception e) { - e.printStackTrace(); - } - } - - @SuppressWarnings("rawtypes") - @Test - public void testBuildNestedVfcToscaNamespace() { - - Class targetClass = ResourceBusinessLogic.class; - String methodName = "buildNestedVfcToscaNamespace"; - String nodeTypeFullName = "org.openecomp.resource.abstract.nodes.heat.FEAdd_On_Module_vLBAgentTemplate"; - String expectedNestedVfcToscaNamespace = "org.openecomp.resource.vfc.nodes.heat.FEAdd_On_Module_vLBAgentTemplate"; - Object[] argObjects = { nodeTypeFullName }; - Class[] argClasses = { String.class }; - try { - Method method = targetClass.getDeclaredMethod(methodName, argClasses); - method.setAccessible(true); - String actualNestedVfcToscaNamespace = (String) method.invoke(bl, argObjects); - assertTrue(!actualNestedVfcToscaNamespace.isEmpty()); - assertTrue(actualNestedVfcToscaNamespace.equals(expectedNestedVfcToscaNamespace)); + .left() + .value(); + assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.CREATE) + .size()); + assertEquals(4, foundVfArtifacts.get(ArtifactOperationEnum.UPDATE) + .size()); + assertEquals(1, foundVfArtifacts.get(ArtifactOperationEnum.DELETE) + .size()); } catch (Exception e) { e.printStackTrace(); } } - @SuppressWarnings("rawtypes") @Test - public void testBuildNestedVfcToscaResourceName() { - - Class targetClass = ResourceBusinessLogic.class; - String methodName = "buildNestedVfcToscaResourceName"; - String vfResourceName = "vfname"; - String nodeTypeFullName = "org.openecomp.resource.abstract.nodes.heat.FEAdd_On_Module_vLBAgentTemplate"; - String expectedNestedVfcToscaResourceName = "org.openecomp.resource.vfc.vfname.abstract.nodes.heat.FEAdd_On_Module_vLBAgentTemplate"; - Object[] argObjects = { vfResourceName, nodeTypeFullName }; - Class[] argClasses = { String.class, String.class }; - try { - Method method = targetClass.getDeclaredMethod(methodName, argClasses); - method.setAccessible(true); - String actualNestedVfcToscaResourceName = (String) method.invoke(bl, argObjects); - assertTrue(!actualNestedVfcToscaResourceName.isEmpty()); - assertTrue(actualNestedVfcToscaResourceName.equals(expectedNestedVfcToscaResourceName)); - - } catch (Exception e) { - e.printStackTrace(); - } - } - - @SuppressWarnings("rawtypes") - @Test - public void testBuildNestedSubstituteYamlName() { - - Class targetClass = ResourceBusinessLogic.class; - String methodName = "buildNestedSubstituteYamlName"; - String nodeTypeFullName = "org.openecomp.resource.abstract.nodes.heat.FEAdd_On_Module_vLBAgentTemplate"; - String expectedNestedSubstituteYamlName = "Definitions/FEAdd_On_Module_vLBAgentTemplateServiceTemplate.yaml"; - Object[] argObjects = { nodeTypeFullName }; - Class[] argClasses = { String.class }; - try { - Method method = targetClass.getDeclaredMethod(methodName, argClasses); - method.setAccessible(true); - String actualNestedSubstituteYamlName = (String) method.invoke(bl, argObjects); - assertTrue(!actualNestedSubstituteYamlName.isEmpty()); - assertTrue(actualNestedSubstituteYamlName.equals(expectedNestedSubstituteYamlName)); - - } catch (Exception e) { - e.printStackTrace(); + public void testVFGeneratedInputs() { + validateUserRoles(Role.ADMIN, Role.DESIGNER); + Resource resource = createVF(); + List inputs = resource.getInputs(); + assertEquals(6, inputs.size()); + for (InputDefinition input : inputs) { + assertThat(input.getOwnerId()).isNotNull(); } + assertEquals(resource.getDerivedFromGenericType(), genericVF.getToscaResourceName()); + assertEquals(resource.getDerivedFromGenericVersion(), genericVF.getVersion()); } @Test - public void testVFGeneratedInputs() { - - Resource resource = createVF(); + public void testCRGeneratedInputs() { + validateUserRoles(Role.ADMIN, Role.DESIGNER); + Resource resource = createCR(); List inputs = resource.getInputs(); - assertTrue(8 == inputs.size()); + assertEquals(3, inputs.size()); for (InputDefinition input : inputs) { - assertNotNull(input.getOwnerId()); + assertThat(input.getOwnerId()).isNotNull(); } - assertTrue(resource.getDerivedFromGenericType().equals(genericVF.getToscaResourceName())); - assertTrue(resource.getDerivedFromGenericVersion().equals(genericVF.getVersion())); + assertEquals(resource.getDerivedFromGenericType(), genericCR.getToscaResourceName()); + assertEquals(resource.getDerivedFromGenericVersion(), genericCR.getVersion()); } @Test public void testVFUpdateGenericInputsToLatestOnCheckout() { - + validateUserRoles(Role.ADMIN, Role.DESIGNER); // create a VF that is derived from generic version 1.0 Resource resource = createVF(); // create a new generic version without properties @@ -1833,19 +1933,27 @@ public class ResourceBusinessLogicTest { List currentInputs = resource.getInputs(); // verify previous inputs ownerId fields exist - user may not delete // generated inputs - assertTrue(8 == currentInputs.stream().filter(p -> null != p.getOwnerId()).collect(Collectors.toList()).size()); + assertEquals(6, currentInputs.stream() + .filter(p -> null != p.getOwnerId()) + .collect(Collectors.toList()) + .size()); Either upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource); // verify success assertTrue(upgradeToLatestGeneric.isLeft()); // verify update required and valid - assertTrue(upgradeToLatestGeneric.left().value()); + assertTrue(upgradeToLatestGeneric.left() + .value()); // verify version was upgraded - assertFalse(resource.getDerivedFromGenericVersion().equals(currentDerivedFromVersion)); + assertNotEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion); // verify inputs were not deleted - assertTrue(8 == resource.getInputs().size()); + assertEquals(6, resource.getInputs() + .size()); // verify inputs ownerId fields were removed - user may delete/edit // inputs - assertTrue(8 == resource.getInputs().stream().filter(p -> null == p.getOwnerId()).collect(Collectors.toList()) + assertEquals(6, resource.getInputs() + .stream() + .filter(p -> null == p.getOwnerId()) + .collect(Collectors.toList()) .size()); } @@ -1853,52 +1961,70 @@ public class ResourceBusinessLogicTest { public void testVFUpdateGenericInputsToLatestOnCheckoutNotPerformed() { // create a VF that is derived from generic version 1.0 + validateUserRoles(Role.ADMIN, Role.DESIGNER); Resource resource = createVF(); // add an input to the VF PropertyDefinition newProp = new PropertyDefinition(); newProp.setType("integer"); newProp.setName("newProp"); - resource.getInputs().add(new InputDefinition(newProp)); + resource.getInputs() + .add(new InputDefinition(newProp)); // create a new generic version with a new property which has the same // name as a user defined input on the VF with a different type genericVF.setVersion("2.0"); newProp.setType("string"); - genericVF.setProperties(new ArrayList()); - genericVF.getProperties().add(newProp); - + genericVF.setProperties(new ArrayList<>()); + genericVF.getProperties() + .add(newProp); + when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF)); + when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), + genericVF.getUniqueId())).thenCallRealMethod(); String currentDerivedFromVersion = resource.getDerivedFromGenericVersion(); - assertTrue(8 == resource.getInputs().stream().filter(p -> null != p.getOwnerId()).collect(Collectors.toList()) + assertEquals(6, resource.getInputs() + .stream() + .filter(p -> null != p.getOwnerId()) + .collect(Collectors.toList()) .size()); Either upgradeToLatestGeneric = bl.shouldUpgradeToLatestGeneric(resource); // verify success assertTrue(upgradeToLatestGeneric.isLeft()); // verify update is invalid an void - assertFalse(upgradeToLatestGeneric.left().value()); + assertFalse(upgradeToLatestGeneric.left() + .value()); // verify version was not upgraded - assertTrue(resource.getDerivedFromGenericVersion().equals(currentDerivedFromVersion)); + assertEquals(resource.getDerivedFromGenericVersion(), currentDerivedFromVersion); // verify inputs were not removed - assertTrue(9 == resource.getInputs().size()); + assertEquals(7, resource.getInputs() + .size()); // verify user defined input exists - assertTrue(1 == resource.getInputs().stream().filter(p -> null == p.getOwnerId()).collect(Collectors.toList()) + assertEquals(1, resource.getInputs() + .stream() + .filter(p -> null == p.getOwnerId()) + .collect(Collectors.toList()) .size()); - assertTrue(resource.getInputs().stream().filter(p -> null == p.getOwnerId()).findAny().get().getType() - .equals("integer")); + assertEquals("integer", resource.getInputs() + .stream() + .filter(p -> null == p.getOwnerId()) + .findAny() + .get() + .getType()); } @Test public void testPNFGeneratedInputsNoGeneratedInformationalArtifacts() { - + validateUserRoles(Role.ADMIN, Role.DESIGNER); Resource resource = createPNF(); List inputs = resource.getInputs(); - assertTrue(8 == inputs.size()); + assertEquals(3, inputs.size()); for (InputDefinition input : inputs) { - assertNotNull(input.getOwnerId()); + assertThat(input.getOwnerId()).isNotNull(); } - assertTrue(resource.getDerivedFromGenericType().equals(genericPNF.getToscaResourceName())); - assertTrue(resource.getDerivedFromGenericVersion().equals(genericPNF.getVersion())); - assertTrue(0 == resource.getArtifacts().size()); + assertEquals(resource.getDerivedFromGenericType(), genericPNF.getToscaResourceName()); + assertEquals(resource.getDerivedFromGenericVersion(), genericPNF.getVersion()); + assertEquals(0, resource.getArtifacts() + .size()); } private Resource createVF() { @@ -1910,10 +2036,38 @@ public class ResourceBusinessLogicTest { resource.setDerivedFrom(null); resource.setResourceType(ResourceTypeEnum.VF); when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource)); - Either createResponse = bl.createResource(resource, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isLeft()); - return createResponse.left().value(); + when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericVF)); + when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericVF)).thenCallRealMethod(); + when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericVF.getProperties(), + resource.getUniqueId())).thenCallRealMethod(); + Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + assertThat(createdResource).isNotNull(); + return createdResource; + } + + private Resource createRoot() { + rootType = setupGenericTypeMock(GENERIC_ROOT_NAME); + when(toscaOperationFacade.getLatestByToscaResourceName(GENERIC_ROOT_NAME)) + .thenReturn(Either.left(rootType)); + return rootType; + } + + private Resource createCR() { + + genericCR = setupGenericTypeMock(GENERIC_CR_NAME); + when(toscaOperationFacade.getLatestCertifiedNodeTypeByToscaResourceName(GENERIC_CR_NAME)) + .thenReturn(Either.left(genericCR)); + Resource resource = createResourceObject(true); + resource.setDerivedFrom(null); + resource.setResourceType(ResourceTypeEnum.CR); + when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource)); + when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericCR)); + when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericCR)).thenCallRealMethod(); + when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericCR.getProperties(), + resource.getUniqueId())).thenCallRealMethod(); + Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + assertThat(createdResource).isNotNull(); + return createdResource; } private Resource createPNF() { @@ -1925,10 +2079,49 @@ public class ResourceBusinessLogicTest { resource.setDerivedFrom(null); resource.setResourceType(ResourceTypeEnum.PNF); when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource)); - Either createResponse = bl.createResource(resource, - AuditingActionEnum.CREATE_RESOURCE, user, null, null); - assertTrue(createResponse.isLeft()); - return createResponse.left().value(); + when(genericTypeBusinessLogic.fetchDerivedFromGenericType(resource)).thenReturn(Either.left(genericPNF)); + when(genericTypeBusinessLogic.generateInputsFromGenericTypeProperties(genericPNF)).thenCallRealMethod(); + when(genericTypeBusinessLogic.convertGenericTypePropertiesToInputsDefintion(genericPNF.getProperties(), + resource.getUniqueId())).thenCallRealMethod(); + Resource createdResource = bl.createResource(resource, AuditingActionEnum.CREATE_RESOURCE, user, null, null); + assertThat(createdResource).isNotNull(); + return createdResource; + } + + private Map getGenericPropertiesByToscaName(String toscaName) { + HashMap PNFProps = new HashMap() { + { + put("nf_function", "string"); + put("nf_role", "string"); + put("nf_type", "string"); + } + }; + + HashMap CRProps = new HashMap() { + { + put("cr_function", "string"); + put("cr_role", "string"); + put("cr_type", "string"); + } + }; + + HashMap VFProps = new HashMap() { + { + putAll(CRProps); + put("availability_zone_max_count", "integer"); + put("min_instances", "integer"); + put("max_instances", "integer"); + } + }; + + if (toscaName.contains("PNF")) + return PNFProps; + if (toscaName.contains("CR")) + return CRProps; + if (toscaName.contains("VF")) + return VFProps; + + return new HashMap<>(); } private Resource setupGenericTypeMock(String toscaName) { @@ -1936,442 +2129,97 @@ public class ResourceBusinessLogicTest { Resource genericType = createResourceObject(true); genericType.setVersion("1.0"); genericType.setToscaResourceName(toscaName); - String[] propNames = { "nf_function", "nf_role", "nf_naming_code", "nf_type", "nf_naming", - "availability_zone_max_count", "min_instances", "max_instances" }; - String[] propTypes = { "string", "string", "string", "string", "org.openecomp.datatypes.Naming", "integer", - "integer", "integer" }; + genericType.setAbstract(true); List genericProps = new ArrayList<>(); - for (int i = 0; i < 8; ++i) { + Map genericPropsMap = getGenericPropertiesByToscaName(toscaName); + genericPropsMap.forEach((name, type) -> { PropertyDefinition prop = new PropertyDefinition(); - prop.setName(propNames[i]); - prop.setType(propTypes[i]); + prop.setName(name); + prop.setType(type); genericProps.add(prop); - } + }); + genericType.setProperties(genericProps); return genericType; } - private ResourceBusinessLogic createTestSubject() { - return new ResourceBusinessLogic(); + private void validateUserRoles(Role... roles) { + List listOfRoles = Stream.of(roles) + .collect(Collectors.toList()); } @Test - public void testGetCsarOperation() throws Exception { - ResourceBusinessLogic testSubject; - CsarOperation result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCsarOperation(); + public void testUpdateVolumeGroup() { + Resource resource = getResourceWithType("HEAT_VOL", "org.openecomp.groups.VfModule"); + bl.updateVolumeGroup(resource); + assertThat(resource.getGroups().get(0).getProperties().get(0).getValue()).isEqualTo(Boolean.toString(true)); } @Test - public void testSetCsarOperation() throws Exception { - ResourceBusinessLogic testSubject; - CsarOperation csarOperation = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCsarOperation(csarOperation); + public void testUpdateVolumeGroupNull() { + Resource resource = getResourceWithType("HEAT_VOL", "org.openecomp.groups.VfModule"); + resource.setGroups(null); + bl.updateVolumeGroup(resource); } - @Test - public void testGetLifecycleBusinessLogic() throws Exception { - ResourceBusinessLogic testSubject; - LifecycleBusinessLogic result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getLifecycleBusinessLogic(); - } - - - @Test - public void testSetLifecycleManager() throws Exception { - ResourceBusinessLogic testSubject; - LifecycleBusinessLogic lifecycleBusinessLogic = null; - - // default test - testSubject = createTestSubject(); - testSubject.setLifecycleManager(lifecycleBusinessLogic); - } - - - @Test - public void testGetElementDao() throws Exception { - ResourceBusinessLogic testSubject; - IElementOperation result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getElementDao(); - } - - - @Test - public void testSetElementDao() throws Exception { - ResourceBusinessLogic testSubject; - IElementOperation elementDao = null; - - // default test - testSubject = createTestSubject(); - testSubject.setElementDao(elementDao); + public void testUpdateVolumeGroupFail() { + Resource resource = getResourceWithType("NON_EXIST_HEAT", "org.openecomp.groups.VfModule"); + bl.updateVolumeGroup(resource); + assertThat(resource.getGroups().get(0).getProperties().get(0).getValue()).isEqualTo(Boolean.toString(false)); } - - @Test - public void testGetUserAdmin() throws Exception { - ResourceBusinessLogic testSubject; - IUserBusinessLogic result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getUserAdmin(); - } - - - @Test - public void testSetUserAdmin() throws Exception { - ResourceBusinessLogic testSubject; - UserBusinessLogic userAdmin = null; - - // default test - testSubject = createTestSubject(); - testSubject.setUserAdmin(userAdmin); - } - - - @Test - public void testGetComponentsUtils() throws Exception { - ResourceBusinessLogic testSubject; - ComponentsUtils result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getComponentsUtils(); - } - - - @Test - public void testSetComponentsUtils() throws Exception { - ResourceBusinessLogic testSubject; - ComponentsUtils componentsUtils = null; - - // default test - testSubject = createTestSubject(); - testSubject.setComponentsUtils(componentsUtils); - } - - - @Test - public void testGetArtifactsManager() throws Exception { - ResourceBusinessLogic testSubject; - ArtifactsBusinessLogic result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getArtifactsManager(); - } - - - @Test - public void testSetArtifactsManager() throws Exception { - ResourceBusinessLogic testSubject; - ArtifactsBusinessLogic artifactsManager = null; - - // default test - testSubject = createTestSubject(); - testSubject.setArtifactsManager(artifactsManager); - } - - - @Test - public void testSetPropertyOperation() throws Exception { - ResourceBusinessLogic testSubject; - IPropertyOperation propertyOperation = null; - - // default test - testSubject = createTestSubject(); - testSubject.setPropertyOperation(propertyOperation); - } - - - @Test - public void testGetApplicationDataTypeCache() throws Exception { - ResourceBusinessLogic testSubject; - ApplicationDataTypeCache result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getApplicationDataTypeCache(); - } - - - @Test - public void testSetApplicationDataTypeCache() throws Exception { - ResourceBusinessLogic testSubject; - ApplicationDataTypeCache applicationDataTypeCache = null; - - // default test - testSubject = createTestSubject(); - testSubject.setApplicationDataTypeCache(applicationDataTypeCache); - } - - @Test - public void testSetDeploymentArtifactsPlaceHolder() throws Exception { - ResourceBusinessLogic testSubject; - Component component = new Resource() { - }; - User user = null; - - // default test - testSubject = createTestSubject(); - testSubject.setDeploymentArtifactsPlaceHolder(component, user); - } - - - - @Test - public void testValidateVendorReleaseName_1() throws Exception { - ResourceBusinessLogic testSubject; - String vendorRelease = ""; - Either result; - - // test 1 - testSubject = createTestSubject(); - vendorRelease = null; - result = testSubject.validateVendorReleaseName(vendorRelease); - Assert.assertEquals(false, result.left().value()); - - } - - - - - - - @Test - public void testGetCapabilityTypeOperation() throws Exception { - ResourceBusinessLogic testSubject; - ICapabilityTypeOperation result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCapabilityTypeOperation(); - } - - - @Test - public void testSetCapabilityTypeOperation() throws Exception { - ResourceBusinessLogic testSubject; - ICapabilityTypeOperation capabilityTypeOperation = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCapabilityTypeOperation(capabilityTypeOperation); - } - - - @Test - public void testValidatePropertiesDefaultValues() throws Exception { - ResourceBusinessLogic testSubject; - Resource resource = new Resource(); - Either result; - - // default test - testSubject = createTestSubject(); - result = testSubject.validatePropertiesDefaultValues(resource); - } - - - @Test - public void testGetComponentInstanceBL() throws Exception { - ResourceBusinessLogic testSubject; - ComponentInstanceBusinessLogic result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getComponentInstanceBL(); - } - - - - @Test - public void testGetComponentInstancesFilteredByPropertiesAndInputs() throws Exception { - ResourceBusinessLogic testSubject; - String componentId = ""; - ComponentTypeEnum componentTypeEnum = null; - String userId = ""; - String searchText = ""; - Either, ResponseFormat> result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getComponentInstancesFilteredByPropertiesAndInputs(componentId, componentTypeEnum, userId, - searchText); - } - - - - @Test - public void testGetCacheManagerOperation() throws Exception { - ResourceBusinessLogic testSubject; - ICacheMangerOperation result; - - // default test - testSubject = createTestSubject(); - result = testSubject.getCacheManagerOperation(); - } - - - @Test - public void testSetCacheManagerOperation() throws Exception { - ResourceBusinessLogic testSubject; - ICacheMangerOperation cacheManagerOperation = null; - - // default test - testSubject = createTestSubject(); - testSubject.setCacheManagerOperation(cacheManagerOperation); - } - - - @Test - public void testGetElementDao_1() throws Exception { - ResourceBusinessLogic testSubject;IElementOperation result; - - // default test - testSubject=createTestSubject();result=testSubject.getElementDao(); - } - - - @Test - public void testGetAllCertifiedResources() throws Exception { - ResourceBusinessLogic testSubject;boolean getAbstract = false; - HighestFilterEnum highestFilter = null; - String userId = ""; - Either,ResponseFormat> result; - - // default test - } - - - @Test - public void testValidateResourceNameExists() throws Exception { - ResourceBusinessLogic testSubject;String resourceName = ""; - ResourceTypeEnum resourceTypeEnum = null; - String userId = ""; - Either,ResponseFormat> result; - - // default test - } - - - @Test - public void testCreateResource() throws Exception { - ResourceBusinessLogic testSubject;Resource resource = null; - AuditingActionEnum auditingAction = null; - User user = null; - Map csarUIPayload = null; - String payloadName = ""; - Either result; - - // test 1 - testSubject=createTestSubject();payloadName = null; - - // test 2 - testSubject=createTestSubject();payloadName = ""; - } - - - @Test - public void testValidateAndUpdateResourceFromCsar() throws Exception { - ResourceBusinessLogic testSubject;Resource resource = null; - User user = null; - Map csarUIPayload = null; - String payloadName = ""; - String resourceUniqueId = ""; - Either result; - - // test 1 - testSubject=createTestSubject();payloadName = null; - - // test 2 - testSubject=createTestSubject();payloadName = ""; - } - - - - - - + private Resource getResourceWithType(String artifactType, String groupDefinitionType) { + ArtifactDefinition artifactToUpdate = new ArtifactDefinition(); + List groups = new ArrayList<>(); + GroupDefinition gd = new GroupDefinition(); + List properties = new ArrayList<>(); + PropertyDataDefinition pdd = new PropertyDataDefinition(); + Map artifacts = new HashMap<>(); + List artifactsList = new ArrayList<>(); + artifactToUpdate.setArtifactType(artifactType); + artifactToUpdate.setArtifactName(artifactType); + artifactToUpdate.setUniqueId(artifactType); + Resource resource = createResourceObjectCsar(true); + artifactsList.add(artifactToUpdate.getArtifactName()); - - - @Test - public void testCreateResourceFromCsar() throws Exception { - ResourceBusinessLogic testSubject;Resource resource = null; - User user = null; - Either,StorageOperationStatus> csarUIPayload = null; - String csarUUID = ""; - Either result; - - // test 1 - testSubject=createTestSubject();csarUIPayload = null; - } + pdd.setName("volume_group"); + pdd.setValue("true"); + pdd.setType(ToscaPropertyType.BOOLEAN.getType()); - + artifacts.put(artifactToUpdate.getArtifactName(), artifactToUpdate); + properties.add(pdd); + gd.setType(groupDefinitionType); + gd.setProperties(properties); + gd.setArtifacts(artifactsList); + groups.add(gd); - - - - @Test - public void testCreateResourcesFromYamlNodeTypesList() throws Exception { - ResourceBusinessLogic testSubject;String yamlName = ""; - Resource resource = null; - Map mappedToscaTemplate = null; - boolean needLock = false; - Map>> nodeTypesArtifactsToHandle = null; - List nodeTypesNewCreatedArtifacts = null; - Map nodeTypesInfo = null; - CsarInfo csarInfo = null; - Either,ResponseFormat> result; - - // default test + resource.setGroups(groups); + resource.setDeploymentArtifacts(artifacts); + return resource; } - + @Test + public void testgetAllCertifiedResources() throws Exception { + List list = bl.getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, "USER"); + Assert.assertEquals(reslist,list); + } + @Test(expected = StorageException.class) + public void testgetAllCertifiedResources_exception() throws Exception { + List list = bl.getAllCertifiedResources(false, HighestFilterEnum.NON_HIGHEST_ONLY, "USER"); + Assert.assertEquals(reslist,list); + } - - @Test - public void testValidateResourceCreationFromNodeType() throws Exception { - ResourceBusinessLogic testSubject;Resource resource = null; - User creator = null; - Either result; - - // default test - } + @Test + public void testvalidateResourceNameExists() throws Exception { + Either, ResponseFormat> res = bl.validateResourceNameExists("Resource", ResourceTypeEnum.CR, "jh0003"); + Assert.assertEquals(true,res.isLeft()); + } - - @Test - public void testCreateResourceFromNodeType() throws Exception { - ResourceBusinessLogic testSubject;String nodeTypeYaml = ""; - UploadResourceInfo resourceMetaData = null; - User creator = null; - boolean isInTransaction = false; - boolean needLock = false; - Map> nodeTypeArtifactsToHandle = null; - List nodeTypesNewCreatedArtifacts = null; - boolean forceCertificationAllowed = false; - CsarInfo csarInfo = null; - Either,ResponseFormat> result; - - // default test - } }