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;
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<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
-
- CacheMangerOperation cacheManager = Mockito.mock(CacheMangerOperation.class);
-
+ @InjectMocks
+ CsarBusinessLogic csarBusinessLogic ;
+ Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>();
+ List<Resource> 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<ComponentFieldValidator> componentFieldValidators = Arrays.asList(componentNameValidator,
+ componentDescriptionValidator, componentProjectCodeValidator,
+ componentIconValidator, componentContactIdValidator,
+ componentTagsValidator);
+ return new ComponentValidator(componentsUtils,componentFieldValidators);
+ }
+
+ ResourceBusinessLogic bl;
public ResourceBusinessLogicTest() {
-
}
@Before
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");
user.setLastName("Hendrix");
user.setRole(Role.ADMIN.name());
- Either<User, ActionStatus> 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))
when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext);
when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao);
- Either<Integer, StorageOperationStatus> eitherCountRoot = Either.left(1);
Either<Boolean, StorageOperationStatus> 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<Boolean, StorageOperationStatus> eitherCountExist = Either.left(true);
when(toscaOperationFacade.validateComponentNameExists("alreadyExists", ResourceTypeEnum.VFC,
ComponentTypeEnum.RESOURCE)).thenReturn(eitherCountExist);
Either<Boolean, StorageOperationStatus> 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<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
- when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
+ when(toscaOperationFacade.validateToscaResourceNameExists("tosca.nodes.Root")).thenReturn(validateDerivedExists);
Either<Boolean, StorageOperationStatus> 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<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse);
- Either<Integer, StorageOperationStatus> eitherValidate = Either.left(null);
- when(toscaOperationFacade.createToscaComponent(Mockito.any(Resource.class))).thenReturn(eitherCreate);
- when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate);
- Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<String, DataTypeDefinition>();
+ when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate);
+ when(catalogOperation.updateCatalog(Mockito.any(), Mockito.any())).thenReturn(ActionStatus.OK);
+ Map<String, DataTypeDefinition> 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<Component, StorageOperationStatus> 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<Resource>();
+ reslist.add(resourceResponse);
+ reslist.add(genericVF);
+ reslist.add(genericCR);
+ reslist.add(genericVFC);
+ reslist.add(genericPNF);
+ Either<List<Resource>, 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<List<Resource>, 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<String> tgs = new ArrayList<String>();
+ List<String> tgs = new ArrayList<>();
tgs.add("test");
tgs.add(resource.getName());
resource.setTags(tgs);
- List<String> template = new ArrayList<String>();
- template.add("Root");
+ List<String> 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);
resource.setName(RESOURCE_NAME);
resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY);
resource.setDescription("My short description");
- List<String> tgs = new ArrayList<String>();
+ List<String> tgs = new ArrayList<>();
tgs.add("test");
tgs.add(resource.getName());
resource.setTags(tgs);
- List<String> template = new ArrayList<String>();
- template.add("Root");
+ List<String> template = new ArrayList<>();
+ template.add("tosca.nodes.Root");
resource.setDerivedFrom(template);
resource.setVendorName("Motorola");
resource.setVendorRelease("1.0.0");
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);
@Test
public void testHappyScenario() {
+ validateUserRoles(Role.ADMIN, Role.DESIGNER);
Resource resource = createResourceObject(false);
- Either<Resource, ResponseFormat> 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<Resource, StorageOperationStatus> resourceLinkedToCsarRes = Either.left(resource);
when(toscaOperationFacade.getLatestComponentByCsarOrName(ComponentTypeEnum.RESOURCE, resource.getCsarUUID(),
resource.getSystemName())).thenReturn(resourceLinkedToCsarRes);
Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true);
- when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists);
-
+ when(toscaOperationFacade.validateToscaResourceNameExists("tosca.nodes.Root")).thenReturn(validateDerivedExists);
+ Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
+ when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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 ***********************/
String resourceName = "alreadyExists";
Resource resourceExist = createResourceObject(false);
resourceExist.setName(resourceName);
- resourceExist.getTags().add(resourceName);
-
- Either<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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() {
String tooLongResourceName = "zCRCAWjqte0DtgcAAMmcJcXeNubeX1p1vOZNTShAHOYNAHvV3iK";
resourceExccedsNameLimit.setName(tooLongResourceName);
- Either<Resource, ResponseFormat> 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() {
String nameWrongFormat = "ljg?fd";
resource.setName(nameWrongFormat);
- Either<Resource, ResponseFormat> 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
+ "scTZ62IxIcIWCVeMjBIcTviXULbPUyqlfEPXWr8IMJtpAaELWgyquPClAREMDs2b9ztKmUeXlMccFES1XWbFTrhBHhmmDyVReEgCwfokrUFR13LTUK1k8I6OEHOs";
resourceExccedsDescLimit.setDescription(tooLongResourceDesc);
-
- Either<Resource, ResponseFormat> 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() {
String notEnglishDesc = "\uC2B5";
notEnglish.setDescription(notEnglishDesc);
- Either<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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
Resource resourceExist = createResourceObject(false);
resourceExist.setIcon(null);
- Either<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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
private void testResourceTagNotExist() {
Resource resourceExist = createResourceObject(false);
resourceExist.setTags(null);
-
- Either<Resource, ResponseFormat> 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<String>());
-
- Either<Resource, ResponseFormat> 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() {
String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
- List<String> tagsList = new ArrayList<String>();
+ List<String> tagsList = new ArrayList<>();
tagsList.add(tag1);
tagsList.add(tag2);
tagsList.add(tag3);
tagsList.add(resourceExccedsNameLimit.getName());
resourceExccedsNameLimit.setTags(tagsList);
-
- Either<Resource, ResponseFormat> 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<String> tagsList = new ArrayList<String>();
+ List<String> tagsList = new ArrayList<>();
tagsList.add(tag1);
tagsList.add(tag2);
resourceExccedsNameLimit.setTags(tagsList);
-
- Either<Resource, ResponseFormat> 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<String> tagsList = new ArrayList<String>();
+ List<String> tagsList = new ArrayList<>();
tagsList.add(tag1);
serviceExccedsNameLimit.setTags(tagsList);
-
- Either<Resource, ResponseFormat> 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<String> tagsList = new ArrayList<String>();
+ List<String> tagsList = new ArrayList<>();
tagsList.add(tag1);
serviceExccedsNameLimit.setTags(tagsList);
-
- Either<Resource, ResponseFormat> 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
String contactIdTooLong = "thisNameIsVeryLongAndExeccedsTheNormalLengthForContactId";
resourceContactId.setContactId(contactIdTooLong);
- Either<Resource, ResponseFormat> 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() {
// 3 letters and 3 digits and special characters
String contactIdFormatWrong = "yrt134!!!";
resourceContactId.setContactId(contactIdFormatWrong);
-
- Either<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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() {
// contains *
String nameWrongFormat = "ljg*fd";
resource.setVendorName(nameWrongFormat);
-
- Either<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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
private void testResourceCategoryExist() {
Resource resourceExist = createResourceObject(false);
resourceExist.setCategories(null);
-
- Either<Resource, ResponseFormat> 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() {
Resource resourceExist = createResourceObject(false);
resourceExist.setCategories(null);
resourceExist.addCategory("koko", "koko");
-
- Either<Resource, ResponseFormat> 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
Resource createResourceObjectAfterCreate = createResourceObject(true);
// Adding cost and licenseType to basic mock
Either<Resource, StorageOperationStatus> 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<Resource, ResponseFormat> 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() {
// Comma instead of fullstop
String cost = "12356,464";
resourceCost.setCost(cost);
-
- Either<Resource, ResponseFormat> 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
// lowcase
String licenseType = "cpu";
resourceLicenseType.setLicenseType(licenseType);
-
- Either<Resource, ResponseFormat> 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
Resource resourceExist = createResourceObject(false);
List<String> list = null;
resourceExist.setDerivedFrom(list);
-
- Either<Resource, ResponseFormat> 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<String>());
-
- Either<Resource, ResponseFormat> 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<String> derivedFrom = new ArrayList<String>();
+ ArrayList<String> 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<Resource, ResponseFormat> 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<Resource, ResponseFormat> 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<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
-
- Either<Resource, ResponseFormat> 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<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
-
- Either<Resource, ResponseFormat> 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<Component, StorageOperationStatus> 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<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
- when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
-
- Either<Resource, ResponseFormat> 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<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
updatedResource.setName(resourceName);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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);
+ }
}
//
updatedResource.setDescription(tooLongResourceDesc);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
updatedResource.setIcon(icon);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
-
- Either<Resource, ResponseFormat> 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
;
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
String tag20 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj5";
String tag21 = "I63llMSEF12FntTwpMt64JhopkjQZzv5KS7mBoRku42PYLrBj0";
- List<String> tagsList = new ArrayList<String>();
+ List<String> tagsList = new ArrayList<>();
tagsList.add(tag1);
tagsList.add(tag2);
tagsList.add(tag3);
updatedResource.setTags(tagsList);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
updatedResource.setVendorName(nameWrongFormat);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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);
;
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
updatedResource.setVendorRelease(tooLongVendorRelease);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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<Component, StorageOperationStatus> 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<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
- when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
updatedResource.addCategory(badCategory, "fikt");
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
resource.setVersion("1.0");
;
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
- when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
updatedResource.setDerivedFrom(list);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
- updatedResource.setDerivedFrom(new ArrayList<String>());
+ updatedResource.setDerivedFrom(new ArrayList<>());
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
Either<Component, StorageOperationStatus> eitherUpdate = Either.left(setCanWorkOnResource(resource));
when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
- ArrayList<String> derivedFrom = new ArrayList<String>();
+ ArrayList<String> derivedFrom = new ArrayList<>();
derivedFrom.add("kuku");
updatedResource.setDerivedFrom(derivedFrom);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> 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
when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(true);
- when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString()))
+ when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString()))
.thenReturn(isToscaNameExtending);
Either<Map<String, PropertyDefinition>, 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<String> derivedFrom = new ArrayList<String>();
+ ArrayList<String> derivedFrom = new ArrayList<>();
derivedFrom.add("tosca.nodes.Root");
updatedResource.setDerivedFrom(derivedFrom);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(updatedResource);
when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null,
- user, false);
- assertTrue(createResponse.isLeft());
+ Resource createdResource = bl.updateResourceMetadata(resourceId, updatedResource, null, user, false);
+ assertThat(createdResource).isNotNull();
}
@Test
when(toscaOperationFacade.getToscaElement(resource.getUniqueId())).thenReturn(eitherUpdate);
Either<Boolean, StorageOperationStatus> isToscaNameExtending = Either.left(false);
- when(toscaOperationFacade.validateToscaResourceNameExtends(Mockito.anyString(), Mockito.anyString()))
+ when(toscaOperationFacade.validateToscaResourceNameExtends(anyString(), anyString()))
.thenReturn(isToscaNameExtending);
resource.setVersion("1.0");
- ArrayList<String> derivedFrom = new ArrayList<String>();
+ ArrayList<String> derivedFrom = new ArrayList<>();
derivedFrom.add("tosca.nodes.Root");
updatedResource.setDerivedFrom(derivedFrom);
Either<Resource, StorageOperationStatus> dataModelResponse = Either.left(resource);
- when(toscaOperationFacade.updateToscaElement(resource)).thenReturn(dataModelResponse);
- Either<Resource, ResponseFormat> createResponse = bl.updateResourceMetadata(resourceId, updatedResource, null,
- user, false);
- assertTrue(createResponse.isRight());
+ when(toscaOperationFacade.updateToscaElement(updatedResource)).thenReturn(dataModelResponse);
+ Either<Map<String, PropertyDefinition>, 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<Resource, ResponseFormat> createResponse = bl.createResource(resourceExist,
- AuditingActionEnum.CREATE_RESOURCE, user, null, null);
-
- createResponse.left().value().setLastUpdaterUserId(user.getUserId());
- assertTrue(createResponse.isLeft());
-
- Either<Component, StorageOperationStatus> 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<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
+ Either<Component, StorageOperationStatus> 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<ImmutablePair<Resource, ActionStatus>, ResponseFormat> createOrUpdateResource = bl
- .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null);
- assertTrue(createOrUpdateResource.isLeft());
+ ImmutablePair<Resource, ActionStatus> 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<Resource, ResponseFormat> 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<Component, StorageOperationStatus> 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<Resource, StorageOperationStatus> getLatestResult = Either.left(createdResource);
+ Either<Component, StorageOperationStatus> 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<ImmutablePair<Resource, ActionStatus>, ResponseFormat> createOrUpdateResource = bl
- .createOrUpdateResourceByImport(resourceToUpdtae, user, false, false, false, null);
- assertTrue(createOrUpdateResource.isLeft());
+ ImmutablePair<Resource, ActionStatus> 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());
}
when(toscaOperationFacade.getLatestByToscaResourceName(resourceToUpdtae.getToscaResourceName()))
.thenReturn(getLatestToscaNameResult);
- Either<ImmutablePair<Resource, ActionStatus>, 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<Resource, ActionStatus> 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<String> definedNodeTypeNamespaceList = ConfigurationManager.getConfigurationManager()
+ .getConfiguration().getDefinedResourceNamespace();
+
+ definedNodeTypeNamespaceList.parallelStream().forEach(validNodeTypePrefix -> {
+ final String nodeName = validNodeTypePrefix + "." + "abc";
+ final Optional<String> 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<Resource, ActionStatus> 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<Resource, ActionStatus> 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<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
- assertTrue(validatePropertiesDefaultValues.isLeft());
+ Boolean validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
+ assertTrue(validatePropertiesDefaultValues);
}
@Test
basic.setProperties(properties);
when(propertyOperation.isPropertyTypeValid(property)).thenReturn(true);
when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(true);
- Either<Boolean, ResponseFormat> 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();
basic.setProperties(properties);
when(propertyOperation.isPropertyDefaultValueValid(property, emptyDataTypes)).thenReturn(false);
- Either<Boolean, ResponseFormat> validatePropertiesDefaultValues = bl.validatePropertiesDefaultValues(basic);
- assertTrue(validatePropertiesDefaultValues.isRight());
+ bl.validatePropertiesDefaultValues(basic);
}
// @Test
// Mockito.times(1)).deleteAllComponentArtifactsIfNotOnGraph(artifacts);
// }
-
@SuppressWarnings("unchecked")
@Test
public void testFindVfCsarArtifactsToHandle() {
String artifactInfoToUpdateFileName = "infoArtifactToUpdate.yaml";
String artifactInfoToDeleteFileName = "infoArtifactToDelete.yaml";
+ String artifactInfoToNotDeleteFileName = "infoArtifactNotToDelete.yaml";
String artifactInfoToCreateFileName = "infoArtifactToCreate.yaml";
byte[] oldPayloadData = "oldPayloadData".getBytes();
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);
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 };
.invoke(bl, argObjects);
assertTrue(findVfCsarArtifactsToHandleRes.isLeft());
EnumMap<ArtifactOperationEnum, List<NonMetaArtifactInfo>> 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<ResourceBusinessLogic> 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<ResourceBusinessLogic> 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<ResourceBusinessLogic> 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<InputDefinition> 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<InputDefinition> 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
List<InputDefinition> 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<Boolean, ResponseFormat> 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());
}
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<PropertyDefinition>());
- 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<Boolean, ResponseFormat> 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<InputDefinition> 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() {
resource.setDerivedFrom(null);
resource.setResourceType(ResourceTypeEnum.VF);
when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
- Either<Resource, ResponseFormat> 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() {
resource.setDerivedFrom(null);
resource.setResourceType(ResourceTypeEnum.PNF);
when(toscaOperationFacade.createToscaComponent(resource)).thenReturn(Either.left(resource));
- Either<Resource, ResponseFormat> 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<String, String> getGenericPropertiesByToscaName(String toscaName) {
+ HashMap<String, String> PNFProps = new HashMap<String, String>() {
+ {
+ put("nf_function", "string");
+ put("nf_role", "string");
+ put("nf_type", "string");
+ }
+ };
+
+ HashMap<String, String> CRProps = new HashMap<String, String>() {
+ {
+ put("cr_function", "string");
+ put("cr_role", "string");
+ put("cr_type", "string");
+ }
+ };
+
+ HashMap<String, String> VFProps = new HashMap<String, String>() {
+ {
+ 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) {
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<PropertyDefinition> genericProps = new ArrayList<>();
- for (int i = 0; i < 8; ++i) {
+ Map<String, String> 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<Role> 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<Boolean, ResponseFormat> 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<Boolean, ResponseFormat> 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<List<ComponentInstance>, 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<List<Resource>,ResponseFormat> result;
-
- // default test
- }
-
-
- @Test
- public void testValidateResourceNameExists() throws Exception {
- ResourceBusinessLogic testSubject;String resourceName = "";
- ResourceTypeEnum resourceTypeEnum = null;
- String userId = "";
- Either<Map<String,Boolean>,ResponseFormat> result;
-
- // default test
- }
-
-
- @Test
- public void testCreateResource() throws Exception {
- ResourceBusinessLogic testSubject;Resource resource = null;
- AuditingActionEnum auditingAction = null;
- User user = null;
- Map<String,byte[]> csarUIPayload = null;
- String payloadName = "";
- Either<Resource,ResponseFormat> 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<String,byte[]> csarUIPayload = null;
- String payloadName = "";
- String resourceUniqueId = "";
- Either<Resource,ResponseFormat> result;
-
- // test 1
- testSubject=createTestSubject();payloadName = null;
-
- // test 2
- testSubject=createTestSubject();payloadName = "";
- }
-
-
-
-
-
-
+ private Resource getResourceWithType(String artifactType, String groupDefinitionType) {
+ ArtifactDefinition artifactToUpdate = new ArtifactDefinition();
+ List<GroupDefinition> groups = new ArrayList<>();
+ GroupDefinition gd = new GroupDefinition();
+ List<PropertyDataDefinition> properties = new ArrayList<>();
+ PropertyDataDefinition pdd = new PropertyDataDefinition();
+ Map<String, ArtifactDefinition> artifacts = new HashMap<>();
+ List<String> 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<Map<String,byte[]>,StorageOperationStatus> csarUIPayload = null;
- String csarUUID = "";
- Either<Resource,ResponseFormat> 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<String,Object> mappedToscaTemplate = null;
- boolean needLock = false;
- Map<String,EnumMap<ArtifactOperationEnum,List<ArtifactDefinition>>> nodeTypesArtifactsToHandle = null;
- List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = null;
- Map<String,NodeTypeInfo> nodeTypesInfo = null;
- CsarInfo csarInfo = null;
- Either<Map<String,Resource>,ResponseFormat> result;
-
- // default test
+ resource.setGroups(groups);
+ resource.setDeploymentArtifacts(artifacts);
+ return resource;
}
-
+ @Test
+ public void testgetAllCertifiedResources() throws Exception {
+ List<Resource> list = bl.getAllCertifiedResources(true, HighestFilterEnum.HIGHEST_ONLY, "USER");
+ Assert.assertEquals(reslist,list);
+ }
+ @Test(expected = StorageException.class)
+ public void testgetAllCertifiedResources_exception() throws Exception {
+ List<Resource> 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<Boolean,ResponseFormat> result;
-
- // default test
- }
+ @Test
+ public void testvalidateResourceNameExists() throws Exception {
+ Either<Map<String, Boolean>, 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<ArtifactOperationEnum,List<ArtifactDefinition>> nodeTypeArtifactsToHandle = null;
- List<ArtifactDefinition> nodeTypesNewCreatedArtifacts = null;
- boolean forceCertificationAllowed = false;
- CsarInfo csarInfo = null;
- Either<ImmutablePair<Resource,ActionStatus>,ResponseFormat> result;
-
- // default test
- }
}