diff options
Diffstat (limited to 'catalog-be/src/test')
8 files changed, 493 insertions, 654 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java index f2d8b57dbf..997d32691b 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogicTest.java @@ -18,432 +18,321 @@ package org.openecomp.sdc.be.components.impl; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; -import static org.mockito.ArgumentMatchers.anyCollection; +import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.anyObject; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.when; import fj.data.Either; -import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.stream.Collectors; -import java.util.stream.Stream; -import javax.servlet.ServletContext; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; -import org.openecomp.sdc.ElementOperationMock; -import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.components.utils.ResourceBuilder; import org.openecomp.sdc.be.components.validation.InterfaceOperationValidation; import org.openecomp.sdc.be.components.validation.UserValidations; -import org.openecomp.sdc.be.config.ConfigurationManager; -import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao; import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; import org.openecomp.sdc.be.dao.jsongraph.TitanDao; import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; 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.impl.ComponentsUtils; -import org.openecomp.sdc.be.impl.WebAppContextWrapper; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.DataTypeDefinition; +import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.InterfaceDefinition; -import org.openecomp.sdc.be.model.LifecycleStateEnum; -import org.openecomp.sdc.be.model.Operation; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.User; -import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation; -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.IElementOperation; -import org.openecomp.sdc.be.model.operations.api.IPropertyOperation; +import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; -import org.openecomp.sdc.be.model.operations.impl.GraphLockOperation; import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; -import org.openecomp.sdc.be.user.Role; -import org.openecomp.sdc.be.user.UserBusinessLogic; -import org.openecomp.sdc.common.api.ConfigurationSource; -import org.openecomp.sdc.common.api.Constants; -import org.openecomp.sdc.common.impl.ExternalConfiguration; -import org.openecomp.sdc.common.impl.FSConfigurationSource; +import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; import org.openecomp.sdc.exception.ResponseFormat; import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils; -import org.springframework.web.context.WebApplicationContext; +@RunWith(MockitoJUnitRunner.class) public class InterfaceOperationBusinessLogicTest { - private static final String RESOURCE_CATEGORY1 = "Network Layer 2-3"; - private static final String RESOURCE_SUBCATEGORY = "Router"; - - private final String resourceId = "resourceId1"; - private final String operationId = "uniqueId1"; - private Operation operation; - + @InjectMocks + private InterfaceOperationBusinessLogic interfaceOperationBusinessLogic; + @Mock + private UserValidations userValidations; + @Mock + private ToscaOperationFacade toscaOperationFacade; + @Mock + private ComponentsUtils componentsUtils; + @Mock + private IGraphLockOperation graphLockOperation; + @Mock + private TitanDao titanDao; + @Mock + private InterfaceLifecycleOperation interfaceLifecycleOperation; + @Mock + private InterfaceOperationValidation interfaceOperationValidation; + @Mock + private InterfaceOperation interfaceOperation; + @Mock + private ArtifactCassandraDao artifactCassandraDao; + + private static final String resourceId = "resourceId"; + private static final String interfaceId = "interfaceId"; + private static final String operationId = "operationId"; + private static final String inputId = "inputId"; private static final String RESOURCE_NAME = "Resource1"; + private static final String operationId1 = "operationId1"; + private static final String interfaceId1 = "interfaceId1"; - private final ServletContext servletContext = Mockito.mock(ServletContext.class); - private final TitanDao mockTitanDao = Mockito.mock(TitanDao.class); - private final UserBusinessLogic mockUserAdmin = Mockito.mock(UserBusinessLogic.class); - private final ToscaOperationFacade toscaOperationFacade = Mockito.mock(ToscaOperationFacade.class); - private final NodeTypeOperation nodeTypeOperation = Mockito.mock(NodeTypeOperation.class); - private final NodeTemplateOperation nodeTemplateOperation = Mockito.mock(NodeTemplateOperation.class); - private final TopologyTemplateOperation topologyTemplateOperation = Mockito.mock(TopologyTemplateOperation.class); - private final IPropertyOperation propertyOperation = Mockito.mock(IPropertyOperation.class); - private final ApplicationDataTypeCache applicationDataTypeCache = Mockito.mock(ApplicationDataTypeCache.class); - private final WebAppContextWrapper webAppContextWrapper = Mockito.mock(WebAppContextWrapper.class); - private final UserValidations userValidations = Mockito.mock(UserValidations.class); - private final WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class); - private final ArtifactCassandraDao artifactCassandraDao = Mockito.mock(ArtifactCassandraDao.class); - private final InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class); - private final InterfaceOperationValidation operationValidator = Mockito.mock(InterfaceOperationValidation.class); - private InterfaceLifecycleOperation interfaceLifecycleOperation = Mockito.mock(InterfaceLifecycleOperation.class); - - private final GraphLockOperation graphLockOperation = Mockito.mock(GraphLockOperation.class); - private User user = null; - private final ArtifactsBusinessLogic artifactManager = new ArtifactsBusinessLogic(); - - @InjectMocks - private - InterfaceOperationBusinessLogic bl = new InterfaceOperationBusinessLogic(); + private User user; + private Resource resource; @Before public void setup() { - 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); - ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class)); + resource = new ResourceBuilder() + .setComponentType(ComponentTypeEnum.RESOURCE) + .setUniqueId(resourceId) + .setName(RESOURCE_NAME) + .build(); + resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId)); + resource.setInputs(createInputsForResource()); - // Elements - IElementOperation mockElementDao = new ElementOperationMock(); - - // User data and management user = new User(); - user.setUserId("jh0003"); - user.setFirstName("Jimmi"); - user.setLastName("Hendrix"); - user.setRole(Role.ADMIN.name()); - - Either<User, ActionStatus> eitherGetUser = Either.left(user); - when(mockUserAdmin.getUser("jh0003", false)).thenReturn(eitherGetUser); - when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(false))).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)).thenReturn(webAppContextWrapper); - when(webAppContextWrapper.getWebAppContext(servletContext)).thenReturn(webAppContext); - when(webAppContext.getBean(IElementOperation.class)).thenReturn(mockElementDao); - - Either<Boolean, StorageOperationStatus> eitherFalse = Either.left(true); - when(toscaOperationFacade.validateComponentNameExists("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(eq(RESOURCE_NAME), any(ResourceTypeEnum.class), eq(ComponentTypeEnum.RESOURCE))).thenReturn(eitherCount); - - Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true); - when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists); - - Either<Boolean, StorageOperationStatus> validateDerivedNotExists = Either.left(false); - when(toscaOperationFacade.validateToscaResourceNameExists("kuku")).thenReturn(validateDerivedNotExists); + when(userValidations.validateUserExists(eq(user.getUserId()), anyString(), eq(true))).thenReturn(user); + when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK); - when(graphLockOperation.lockComponentByName(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.OK); - - // createResource - Resource resourceResponse = createResourceObject(true); - Either<Resource, StorageOperationStatus> eitherCreate = Either.left(resourceResponse); - when(toscaOperationFacade.createToscaComponent(any(Resource.class))).thenReturn(eitherCreate); - //TODO Remove if passes - /*when(toscaOperationFacade.validateCsarUuidUniqueness(Mockito.anyString())).thenReturn(eitherValidate);*/ - Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>(); - when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes)); - - //InterfaceOperation - when(operationValidator.validateInterfaceOperations(anyCollection(), anyObject(), anyBoolean())).thenReturn(Either.left(true)); - when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK); - - // BL object - artifactManager.setNodeTemplateOperation(nodeTemplateOperation); - bl = new InterfaceOperationBusinessLogic(); - - bl.setUserAdmin(mockUserAdmin); - bl.setComponentsUtils(componentsUtils); - bl.setGraphLockOperation(graphLockOperation); - bl.setTitanGenericDao(mockTitanDao); - toscaOperationFacade.setNodeTypeOperation(nodeTypeOperation); - toscaOperationFacade.setTopologyTemplateOperation(topologyTemplateOperation); - bl.setToscaOperationFacade(toscaOperationFacade); - bl.setUserValidations(userValidations); - bl.setInterfaceOperation(interfaceOperation); - bl.setInterfaceOperationValidation(operationValidator); - bl.setInterfaceLifecycleOperation(interfaceLifecycleOperation); - Resource resourceCsar = createResourceObjectCsar(true); - setCanWorkOnResource(resourceCsar); - Either<Component, StorageOperationStatus> oldResourceRes = Either.left(resourceCsar); - when(toscaOperationFacade.getToscaFullElement(resourceCsar.getUniqueId())).thenReturn(oldResourceRes); + when(interfaceOperationValidation.validateInterfaceOperations(anyObject(), anyObject(), any(), anyMap(), anyBoolean())).thenReturn(Either.left(true)); + when(titanDao.commit()).thenReturn(TitanOperationStatus.OK); } @Test - public void createInterfaceOperationTest() { - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - operation = InterfaceOperationTestUtils.createMockOperation(); - when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn())); - - Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true); - Assert.assertTrue(interfaceOperation.isLeft()); - Assert.assertNotNull(interfaceOperation.left().value().getWorkflowId()); - Assert.assertNotNull(interfaceOperation.left().value().getWorkflowVersionId()); + public void createInterfaceOperationTestOnExistingInterface() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic + .createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperationEither.isLeft()); } @Test public void createInterfaceOperationWithoutInterfaceTest() { - Resource resource = createResourceObjectCsar(true); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - resource.setInterfaces(new HashMap<>()); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - operation = InterfaceOperationTestUtils.createMockOperation(); - when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn())); - when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.left(new InterfaceDefinition())); + resource.getInterfaces().clear(); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(interfaceOperation.addInterfaces(any(), any())).thenReturn(Either.left(Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic + .createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperationEither.isLeft()); + } - Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true); - Assert.assertTrue(interfaceOperation.isLeft()); + @Test + public void createInterfaceOperationWithoutInterfaceTestFail() { + resource.getInterfaces().clear(); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(interfaceOperation.addInterfaces(any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic + .createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperationEither.isRight()); + } + @Test + public void shouldFailWhenCreateInterfaceOperationFailedTest() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, + Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true).isRight()); } @Test - public void shouldFailCreateInterfaceOperationWhenCreateOperationFailedTest() { - Resource resource = createResourceObjectCsar(true); - resource.setInterfaces(new HashMap<>()); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - operation = InterfaceOperationTestUtils.createMockOperation(); - when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn())); - when(interfaceOperation.addInterface(anyString(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); + public void updateInterfaceOperationTestWithArtifactSuccess() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(artifactCassandraDao.getCountOfArtifactById(any(String.class))).thenReturn(Either.left(new Long(1))); + when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = + interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperation.isLeft()); + } - Either<Operation, ResponseFormat> interfaceOperation = bl.createInterfaceOperation(resourceId, operation, user, true); + @Test + public void updateInterfaceOperationTestWithArtifactFailure() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(artifactCassandraDao.getCountOfArtifactById(any(String.class))).thenReturn(Either.left(new Long(1))); + when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.GENERAL_ERROR); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = + interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); Assert.assertTrue(interfaceOperation.isRight()); + } + @Test + public void updateInterfaceOperationTestWithoutArtifact() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(artifactCassandraDao.getCountOfArtifactById(any(String.class))).thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND)); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)))); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = + interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperation.isLeft()); } - @Test() - public void shouldFailWhenCreateInterfaceOperationFailedTest() { - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - operation = InterfaceOperationTestUtils.createMockOperation(); + @Test + public void updateInterfaceOperationTestDoesntExist() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperation = + interfaceOperationBusinessLogic.updateInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId1)), user, true); + Assert.assertTrue(interfaceOperation.isRight()); + } - when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); - Assert.assertTrue(bl.createInterfaceOperation(resourceId, operation, user, true).isRight()); + @Test + public void createInterfaceOperationTestFailOnException() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(interfaceOperation.updateInterfaces(any(), any())).thenThrow(new RuntimeException()); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic + .createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperationEither.isRight()); } @Test - public void updateInterfaceOperationTest() { - validateUserRoles(Role.ADMIN, Role.DESIGNER); - operation = InterfaceOperationTestUtils.createMockOperation(); - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - when(interfaceOperation.updateInterfaceOperation(any(), any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn())); + public void createInterfaceOperationTestFailOnFetchinGlobalTypes() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic + .createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperationEither.isRight()); + } - Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true); - Assert.assertTrue(interfaceOperation.isLeft()); + @Test + public void createInterfaceOperationTestFailOnValidation() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); + when(interfaceOperationValidation.validateInterfaceOperations(anyObject(), anyObject(), any(), anyMap(), anyBoolean())).thenReturn(Either.right(new ResponseFormat())); + Either<List<InterfaceDefinition>, ResponseFormat> interfaceOperationEither = interfaceOperationBusinessLogic + .createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true); + Assert.assertTrue(interfaceOperationEither.isRight()); } - @Test() - public void shouldFailWhenFailedToUpdateInterfaceOperationTest() { - validateUserRoles(Role.ADMIN, Role.DESIGNER); - operation = InterfaceOperationTestUtils.createMockOperation(); - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - when(interfaceOperation.addInterfaceOperation(any(), any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); - Either<Operation, ResponseFormat> interfaceOperation = bl.updateInterfaceOperation(resourceId, operation, user, true); - Assert.assertTrue(interfaceOperation.isRight()); + @Test + public void deleteInterfaceOperationTestInterfaceDoesntExist() { + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId1, Collections.singletonList(operationId), user, true).isRight()); } @Test - public void deleteInterfaceOperationTest() { - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockOperationToReturn())); + public void deleteInterfaceOperationTestOperationDoesntExist() { + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId1), user, true).isRight()); + } + + @Test + public void deleteInterfaceOperationTestSuccess() { + resource.getInterfaces().get(interfaceId).getOperations().putAll(InterfaceOperationTestUtils.createMockOperationMap(operationId1)); when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); - Either<Operation, ResponseFormat> deleteResourceResponseFormatEither = bl.deleteInterfaceOperation(resourceId, operationId, user, true); - Assert.assertTrue(deleteResourceResponseFormatEither.isLeft()); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList())); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isLeft()); } - @Test() + @Test public void shouldFailWhenDeleteInterfaceOperationFailedTest() { - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - when(interfaceOperation.deleteInterfaceOperation(any(),any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); - Assert.assertTrue(bl.deleteInterfaceOperation(resourceId, operationId, user, true).isRight()); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); + } + @Test + public void deleteInterfaceOperationTestFailOnArtifactDeletion() { + when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.GENERAL_ERROR); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); } + @Test - public void getInterfaceOperationTest() { - Resource resource = createResourceForInterfaceOperation(); - resource.setComponentType(ComponentTypeEnum.RESOURCE); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.left(resource)); - Either<Operation, ResponseFormat> getResourceResponseFormatEither = bl.getInterfaceOperation(resourceId, operationId, user, true); - Assert.assertTrue(getResourceResponseFormatEither.isLeft()); + public void deleteInterfaceOperationTestFailOnException() { + when(artifactCassandraDao.deleteArtifact(any(String.class))).thenThrow(new RuntimeException()); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); } @Test - public void updateToscaResourceNameWhenComponentNameChanged() { - Component newComponent = new Resource(); - newComponent.setName("newComponent"); - Component oldComponent = createResourceForInterfaceOperation(); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(interfaceOperation.updateInterface(anyString(), any())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME))); - Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isLeft()); + public void deleteInterfaceTestSuccess() { + when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList())); + when(interfaceOperation.deleteInterface(any(), any())).thenReturn(Either.left(interfaceId)); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isLeft()); } @Test - public void shouldFailWhenComponentNameChangedButUpdateOperationFailed() { - Component newComponent = new Resource(); - newComponent.setName("newComponent"); - Component oldComponent = createResourceForInterfaceOperation(); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); - - Assert.assertTrue(bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight()); + public void deleteInterfaceTestFailure() { + when(artifactCassandraDao.deleteArtifact(any(String.class))).thenReturn(CassandraOperationStatus.OK); + when(interfaceOperation.updateInterfaces(any(), any())).thenReturn(Either.left(Collections.emptyList())); + when(interfaceOperation.deleteInterface(any(), any())).thenReturn(Either.right(StorageOperationStatus.GENERAL_ERROR)); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); } - @Test(expected = Exception.class) - public void shouldThrowExceptionWhenComponentNameChangedButUpdateOperationFailed() { - Component newComponent = new Resource(); - newComponent.setName("newComponent"); - Component oldComponent = createResourceForInterfaceOperation(); - validateUserRoles(Role.ADMIN, Role.DESIGNER); - when(interfaceOperation.updateInterface(anyString(), anyObject())).thenThrow(new Exception()); - bl.validateComponentNameAndUpdateInterfaces(oldComponent, newComponent).isRight(); + @Test + public void getInterfaceOperationTestInterfaceDoesntExist() { + Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId1, Collections.singletonList(operationId), user, true).isRight()); } - private void validateUserRoles(Role... roles) { - List<Role> listOfRoles = Stream.of(roles).collect(Collectors.toList()); + @Test + public void getInterfaceOperationTestOperationDoesntExist() { + Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId1), user, true).isRight()); } - private void setCanWorkOnResource(Resource resource) { - resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - resource.setLastUpdaterUserId(user.getUserId()); + @Test + public void getInterfaceOperationTest() { + Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isLeft()); } - private Resource createResourceForInterfaceOperation() { - Resource resource = new Resource(); - resource.setUniqueId(resourceId); - resource.setName(RESOURCE_NAME); - resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY); - resource.setDescription("Resource name for response"); - resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME)); - return resource; + @Test + public void getInterfaceOperationTestFailOnException() { + when(titanDao.commit()).thenThrow(new RuntimeException()); + Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); } - private Resource createResourceObjectCsar(boolean afterCreate) { - Resource resource = new Resource(); - resource.setName(RESOURCE_NAME); - resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY); - resource.setDescription("My short description"); - List<String> tgs = new ArrayList<>(); - tgs.add("test"); - tgs.add(resource.getName()); - resource.setTags(tgs); - List<String> template = new ArrayList<>(); - template.add("Root"); - resource.setDerivedFrom(template); - resource.setVendorName("Motorola"); - resource.setVendorRelease("1.0.0"); - resource.setResourceVendorModelNumber(""); - resource.setContactId("ya5467"); - resource.setIcon("MyIcon"); - resource.setCsarUUID("valid_vf.csar"); - resource.setCsarVersion("1"); - - if (afterCreate) { - resource.setName(resource.getName()); - resource.setVersion("0.1"); - resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion()); - resource.setCreatorUserId(user.getUserId()); - resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName()); - resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - } - return resource; + @Test + public void shouldFailWhenLockComponentFailedTest() { + when(graphLockOperation.lockComponent(Mockito.anyString(), eq(NodeTypeEnum.Resource))).thenReturn(StorageOperationStatus.NOT_FOUND); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); + Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); + Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true).isRight()); } - private Resource createResourceObject(boolean afterCreate) { - Resource resource = new Resource(); - resource.setName(RESOURCE_NAME); - resource.addCategory(RESOURCE_CATEGORY1, RESOURCE_SUBCATEGORY); - resource.setDescription("My short description"); - List<String> tgs = new ArrayList<>(); - tgs.add("test"); - tgs.add(resource.getName()); - resource.setTags(tgs); - List<String> template = new ArrayList<>(); - template.add("Root"); - resource.setDerivedFrom(template); - resource.setVendorName("Motorola"); - resource.setVendorRelease("1.0.0"); - resource.setContactId("ya5467"); - resource.setIcon("MyIcon"); - - if (afterCreate) { - resource.setName(resource.getName()); - resource.setVersion("0.1"); - resource.setUniqueId(resource.getName().toLowerCase() + ":" + resource.getVersion()); - resource.setCreatorUserId(user.getUserId()); - resource.setCreatorFullName(user.getFirstName() + " " + user.getLastName()); - resource.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT); - } - return resource; + @Test + public void shouldFailWhenGetComponentFailedTest() { + when(toscaOperationFacade.getToscaElement(resourceId)).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + Assert.assertTrue(interfaceOperationBusinessLogic.deleteInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); + Assert.assertTrue(interfaceOperationBusinessLogic.getInterfaceOperation(resourceId, interfaceId, Collections.singletonList(operationId), user, true).isRight()); + Assert.assertTrue(interfaceOperationBusinessLogic.createInterfaceOperation(resourceId, Collections.singletonList(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId)), user, true).isRight()); } @Test public void testGetAllInterfaceLifecycleTypes_TypesNotFound() { when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); - Either<Map<String, InterfaceDefinition>, ResponseFormat> response = bl.getAllInterfaceLifecycleTypes(); + Either<Map<String, InterfaceDefinition>, ResponseFormat> response = interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(); Assert.assertTrue(response.isRight()); } @Test public void testGetAllInterfaceLifecycleTypes_Success() { - final String UNIQUE_ID = "UNIQUE_ID"; - final String TYPE = "UNIQUE_ID"; InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); - interfaceDefinition.setUniqueId(UNIQUE_ID); - interfaceDefinition.setType(TYPE); + interfaceDefinition.setUniqueId(interfaceId); + interfaceDefinition.setType(interfaceId); Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>(); interfaceDefinitionMap.put(interfaceDefinition.getUniqueId(), interfaceDefinition); when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(interfaceDefinitionMap)); - Either<Map<String, InterfaceDefinition>, ResponseFormat> response = bl.getAllInterfaceLifecycleTypes(); + Either<Map<String, InterfaceDefinition>, ResponseFormat> response = interfaceOperationBusinessLogic.getAllInterfaceLifecycleTypes(); Assert.assertEquals(response.left().value().size(),1); } + + private List<InputDefinition> createInputsForResource(){ + InputDefinition inputDefinition = new InputDefinition(); + inputDefinition.setName(inputId); + inputDefinition.setInputId(inputId); + inputDefinition.setUniqueId(inputId); + inputDefinition.setValue(inputId); + inputDefinition.setDefaultValue(inputId); + return Arrays.asList(inputDefinition); + } }
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java index b6a7c98efa..8e35981722 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ResourceBusinessLogicTest.java @@ -32,7 +32,6 @@ import org.openecomp.sdc.ElementOperationMock; import org.openecomp.sdc.be.auditing.impl.AuditingManager; import org.openecomp.sdc.be.datamodel.api.HighestFilterEnum; import org.openecomp.sdc.be.model.operations.StorageException; -import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils; 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; @@ -60,7 +59,6 @@ import org.openecomp.sdc.be.model.PropertyDefinition; import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache; -import org.openecomp.sdc.be.model.jsontitan.operations.InterfaceOperation; 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; @@ -156,8 +154,6 @@ public class ResourceBusinessLogicTest { UserValidations userValidations = Mockito.mock(UserValidations.class); WebApplicationContext webAppContext = Mockito.mock(WebApplicationContext.class); IInterfaceLifecycleOperation interfaceTypeOperation = Mockito.mock(IInterfaceLifecycleOperation.class); - InterfaceOperation interfaceOperation = Mockito.mock(InterfaceOperation.class); - InterfaceOperationBusinessLogic interfaceOperationBl = Mockito.mock(InterfaceOperationBusinessLogic.class); @InjectMocks ResourceBusinessLogic bl = new ResourceBusinessLogic(); @@ -228,7 +224,6 @@ public class ResourceBusinessLogicTest { /*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(RESOURCE_NAME, ResourceTypeEnum.CR, ComponentTypeEnum.RESOURCE)).thenReturn(eitherCount);*/ - when(interfaceOperation.updateInterface(anyString(), anyObject())).thenReturn(Either.left(InterfaceOperationTestUtils.mockInterfaceDefinitionToReturn(RESOURCE_NAME))); Either<Boolean, StorageOperationStatus> validateDerivedExists = Either.left(true); when(toscaOperationFacade.validateToscaResourceNameExists("Root")).thenReturn(validateDerivedExists); @@ -245,7 +240,6 @@ public class ResourceBusinessLogicTest { Map<String, DataTypeDefinition> emptyDataTypes = new HashMap<>(); when(applicationDataTypeCache.getAll()).thenReturn(Either.left(emptyDataTypes)); when(mockTitanDao.commit()).thenReturn(TitanOperationStatus.OK); - when(interfaceOperationBl.validateComponentNameAndUpdateInterfaces(any(Component.class), any(Component.class))).thenReturn(Either.left(true)); // BL object artifactManager.setNodeTemplateOperation(nodeTemplateOperation); @@ -267,8 +261,6 @@ public class ResourceBusinessLogicTest { bl.setToscaOperationFacade(toscaOperationFacade); bl.setUserValidations(userValidations); bl.setInterfaceTypeOperation(interfaceTypeOperation); - bl.setInterfaceOperation(interfaceOperation); - bl.setInterfaceOperationBusinessLogic(interfaceOperationBl); csarBusinessLogic.setCsarOperation(csarOperation); Resource resourceCsar = createResourceObjectCsar(true); @@ -950,7 +942,6 @@ public class ResourceBusinessLogicTest { @Test public void testResourceNameWrongFormat_UPDATE() { Resource resource = createResourceObject(true); - resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME)); Resource updatedResource = createResourceObject(true); // this is in order to prevent failing with 403 earlier @@ -972,7 +963,6 @@ public class ResourceBusinessLogicTest { @Test public void testResourceNameAfterCertify_UPDATE() { Resource resource = createResourceObject(true); - resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME)); Resource updatedResource = createResourceObject(true); // this is in order to prevent failing with 403 earlier @@ -996,7 +986,6 @@ public class ResourceBusinessLogicTest { @Test public void testResourceNameAlreadyExist_UPDATE() { Resource resource = createResourceObject(true); - resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinition(RESOURCE_NAME)); Resource updatedResource = createResourceObject(true); // this is in order to prevent failing with 403 earlier diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java new file mode 100644 index 0000000000..8884f9f2d6 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/utils/InterfaceOperationUtilsTest.java @@ -0,0 +1,80 @@ +package org.openecomp.sdc.be.components.utils; + +import java.util.Map; +import java.util.Optional; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.model.InterfaceDefinition; +import org.openecomp.sdc.be.model.Operation; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils; + +public class InterfaceOperationUtilsTest { + + private static final String TEST_RESOURCE_NAME = "TestResource"; + private static final String operationId = "operationId"; + private static final String interfaceId = "interfaceId"; + private static Resource resource; + + @Before + public void setup() { + resource = new ResourceBuilder() + .setComponentType(ComponentTypeEnum.RESOURCE) + .setName(TEST_RESOURCE_NAME) + .build(); + resource.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId)); + } + + @Test + public void testGetInterfaceDefinitionFromComponentByInterfaceTypeSuccess(){ + Assert.assertTrue(InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, interfaceId).isPresent()); + } + + @Test + public void testGetInterfaceDefinitionFromComponentByInterfaceTypeFailure(){ + Assert.assertFalse(InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, TEST_RESOURCE_NAME).isPresent()); + } + + @Test + public void testGetInterfaceDefinitionFromComponentByInterfaceTypeNoInterface(){ + resource.getInterfaces().clear(); + Assert.assertFalse(InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceType(resource, interfaceId).isPresent()); + } + + @Test + public void testGetInterfaceDefinitionFromComponentByInterfaceIdSuccess(){ + Assert.assertTrue(InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, interfaceId).isPresent()); + } + + @Test + public void testGetInterfaceDefinitionFromComponentByInterfaceIdFailure(){ + Assert.assertFalse(InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, TEST_RESOURCE_NAME).isPresent()); + } + + @Test + public void testGetInterfaceDefinitionFromComponentByInterfaceIdNoInterface(){ + resource.getInterfaces().clear(); + Assert.assertFalse(InterfaceOperationUtils.getInterfaceDefinitionFromComponentByInterfaceId(resource, interfaceId).isPresent()); + } + + @Test + public void testGetOperationFromInterfaceDefinitionSuccess(){ + Assert.assertTrue(InterfaceOperationUtils.getOperationFromInterfaceDefinition(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), operationId).isPresent()); + } + + @Test + public void testGetOperationFromInterfaceDefinitionFailure(){ + Assert.assertFalse(InterfaceOperationUtils.getOperationFromInterfaceDefinition(InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId), TEST_RESOURCE_NAME).isPresent()); + } + + @Test + public void testGetOperationFromInterfaceDefinitionNoOperationMap(){ + InterfaceDefinition interfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceId, operationId); + interfaceDefinition.getOperations().clear(); + Optional<Map.Entry<String, Operation>> operationEntry = InterfaceOperationUtils.getOperationFromInterfaceDefinition(interfaceDefinition, TEST_RESOURCE_NAME); + Assert.assertFalse(operationEntry.isPresent()); + } + +}
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java index 1a112c583b..43d2fe884f 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/validation/InterfaceOperationValidationTest.java @@ -19,264 +19,246 @@ package org.openecomp.sdc.be.components.validation; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.when; -import com.google.common.collect.Sets; -import fj.data.Either; - -import java.util.ArrayList; -import java.util.Collection; +import java.util.Arrays; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Set; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.openecomp.sdc.be.components.impl.ResponseFormatManager; +import org.openecomp.sdc.be.components.utils.ResourceBuilder; import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition; import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; import org.openecomp.sdc.be.model.ArtifactDefinition; -import org.openecomp.sdc.be.model.ComponentInstanceInput; +import org.openecomp.sdc.be.model.Component; import org.openecomp.sdc.be.model.InputDefinition; import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.Operation; -import org.openecomp.sdc.be.model.Component; -import org.openecomp.sdc.be.model.Resource; import org.openecomp.sdc.exception.ResponseFormat; import org.openecomp.sdc.test.utils.InterfaceOperationTestUtils; public class InterfaceOperationValidationTest { - private final Component component = setUpComponentMock(); - private ResponseFormatManager responseFormatManagerMock; - private final InterfaceOperationValidationUtilTest interfaceOperationValidationUtilTest = new InterfaceOperationValidationUtilTest(); private final ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>(); private final ListDataDefinition<OperationOutputDefinition> operationOutputDefinitionList = new ListDataDefinition<>(); + private static final String resourceId = "resourceId"; + private static final String interfaceId = "interfaceId"; + private static final String operationId = "operationId"; + private static final String interfaceType = "interfaceType"; + private static final String operationType = "operationType"; + private static final String operationId2 = "operationId2"; + private static final String inputId = "inputId"; + private static final String outputId = "outputId"; + + private Component component; + private ResponseFormatManager responseFormatManagerMock; @Before - public void init() { + public void setup() { MockitoAnnotations.initMocks(this); responseFormatManagerMock = Mockito.mock(ResponseFormatManager.class); when(responseFormatManagerMock.getResponseFormat(any())).thenReturn(new ResponseFormat()); when(responseFormatManagerMock.getResponseFormat(any(), any())).thenReturn(new ResponseFormat()); when(responseFormatManagerMock.getResponseFormat(any(), any(), any())).thenReturn(new ResponseFormat()); + + component = new ResourceBuilder() + .setComponentType(ComponentTypeEnum.RESOURCE) + .setUniqueId(resourceId) + .setName(resourceId) + .build(); + component.setInterfaces(InterfaceOperationTestUtils.createMockInterfaceDefinitionMap(interfaceId, operationId)); + component.setInputs(createInputsForComponent()); } @Test public void shouldPassOperationValidationForHappyScenario() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"upgrade"); - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isLeft()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"upgrade"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(), false).isLeft()); } @Test - public void shouldFailWhenOperationOperationDescriptionLengthInvalid() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2 - The Spring Initializer provides a project generator to make you " + - "productive with the certain technology stack from the beginning. You can create a skeleton project" + - "with web, data access (relational and NoSQL data stores), cloud, or messaging support", - new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + public void shouldFailWhenOperationNameIsEmpty() { + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, ""); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } - - @Test - public void shouldFailWhenOperationNameIsEmpty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList, ""); - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + public void shouldFailWhenOperationNamesAreNotUniqueForCreate() { + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationId); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } @Test - public void shouldFailWhenOperationNamesAreNotUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"CREATE"); - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + public void shouldNotFailWhenOperationNamesAreNotUniqueForUpdate() { + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList, operationId); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),true).isLeft()); } @Test public void shouldFailWhenOperationNameLengthIsInvalid() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList, - "interface operation2 - The Spring Initializer provides a project generator to make you " + + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, + operationOutputDefinitionList,"interface operation2 - The Spring Initializer provides a project generator to make you " + "productive with the certain technology stack from the beginning. You can create a skeleton project" + "with web, data access (relational and NoSQL data stores), cloud, or messaging support"); - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } - @Test public void shouldFailWhenOperationInputParamNamesAreNotUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"create"); - - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"create"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } @Test public void shouldPassWhenOperationInputParamNamesAreUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"update"); - - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isLeft()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(outputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft()); } @Test public void shouldPassWhenOperationInputParamNamesHasSubProperty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label2")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"update"); - operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(operationInputDefinitionList - .getListToscaDataDefinition().get(0).getInputId().concat(".subproperty")); - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isLeft()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + operationInputDefinitionList.getListToscaDataDefinition().get(0).setInputId(operationInputDefinitionList.getListToscaDataDefinition().get(0).getInputId().concat(".subproperty")); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft()); } @Test public void shouldFailWhenOperationInputParamNameEmpty() { operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(" ")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"update"); - - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } @Test public void shouldFailWhenOperationOutputParamNameEmpty() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("inputParam")); - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(" ")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"update"); - - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } @Test public void shouldPassWhenInterfaceOperationOutputParamNamesUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("label2")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"update"); - - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isLeft()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft()); } @Test public void shouldFailWhenOperationOutputParamNamesAreNotUnique() { - operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition("inputParam1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("outParam1")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("outParam2")); - operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition("outParam2")); - Collection<Operation> operations = createInterfaceOperationData("op2", - "interface operation2",new ArtifactDefinition(), operationInputDefinitionList, - operationOutputDefinitionList,"update"); - - Either<Boolean, ResponseFormat> booleanResponseFormatEither = interfaceOperationValidationUtilTest - .validateInterfaceOperations(operations, component, false); - Assert.assertTrue(booleanResponseFormatEither.isRight()); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); } - private Set<Operation> createInterfaceOperationData( String uniqueID, String description, ArtifactDefinition artifactDefinition, - ListDataDefinition<OperationInputDefinition> inputs, - ListDataDefinition<OperationOutputDefinition> outputs, String name) { - return Sets.newHashSet(InterfaceOperationTestUtils.createInterfaceOperation(uniqueID, description, artifactDefinition, inputs, outputs, name)); + @Test + public void shouldPassWhenOperationInputParamExistInComponentProperty() { + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2, new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isLeft()); } - private Component setUpComponentMock(){ - Component component = new Resource(); + @Test + public void shouldFailWhenOperationInputParamDoesntExistInComponentProperty() { + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(inputId)); + operationInputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationInputDefinition(operationId)); + operationOutputDefinitionList.add(InterfaceOperationTestUtils.createMockOperationOutputDefinition(outputId)); + InterfaceDefinition interfaceDefinition = createInterfaceOperationData(operationId2, operationId2,new ArtifactDefinition(), operationInputDefinitionList, operationOutputDefinitionList,"update"); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(interfaceDefinition, component, component.getInterfaces().get(interfaceId), Collections.emptyMap(),false).isRight()); + } - List<InputDefinition> inputs = new ArrayList<>(); - InputDefinition inputDefinition = new InputDefinition(); - InputDefinition inputDefinition1 = new InputDefinition(); + @Test + public void shouldFailValidateAllowedOperationCountOnLocalInterfaceType() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceId, operationType); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isRight()); + } + + @Test + public void shouldFailValidateAllowedOperationsOnGlobalInterfaceType() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType, operationId); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isRight()); + } - List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>(); - ComponentInstanceInput componentInstanceInput1 = new ComponentInstanceInput(); - componentInstanceInput1.setComponentInstanceName("componentInstance1"); - componentInstanceInput1.setUniqueId("inputId1"); - ComponentInstanceInput componentInstanceInput2 = new ComponentInstanceInput(); - componentInstanceInput2.setComponentInstanceName("componentInstance2"); - componentInstanceInput2.setUniqueId("inputId2"); - - componentInstanceInputs.add(componentInstanceInput1); - componentInstanceInputs.add(componentInstanceInput2); - - inputDefinition.setUniqueId("inputId1"); - inputDefinition.setInputs(componentInstanceInputs); - inputDefinition1.setUniqueId("uniqueId3"); - - inputs.add(inputDefinition); - inputs.add(inputDefinition1); - component.setInputs(inputs); - component.setInterfaces(createMockInterfaceDefinition()); - return component; + @Test + public void shouldPassValidateAllowedOperationsOnGlobalInterfaceType() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isLeft()); } - private Map<String, InterfaceDefinition> createMockInterfaceDefinition() { - Map<String, Operation> operationMap = InterfaceOperationTestUtils.createMockOperationMap(); - Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>(); - interfaceDefinitionMap.put("int1", InterfaceOperationTestUtils.createInterface("int1", "Interface 1", - "lifecycle", "tosca", operationMap)); + @Test + public void shouldFailValidateOperationNameUniquenessInCollection() { + InterfaceDefinition inputInterfaceDefinition = InterfaceOperationTestUtils.createMockInterface(interfaceType, operationType); + inputInterfaceDefinition.getOperations().put(operationId, InterfaceOperationTestUtils.createMockOperation(operationType)); + Assert.assertTrue(interfaceOperationValidationUtilTest.validateInterfaceOperations(inputInterfaceDefinition, component, component.getInterfaces().get(interfaceId), InterfaceOperationTestUtils.createMockInterfaceTypeMap(interfaceType, operationType),false).isRight()); + } - return interfaceDefinitionMap; + private InterfaceDefinition createInterfaceOperationData(String uniqueID, String description, ArtifactDefinition artifactDefinition, + ListDataDefinition<OperationInputDefinition> inputs, + ListDataDefinition<OperationOutputDefinition> outputs, String name) { + Operation operation = new Operation(); + operation.setUniqueId(uniqueID); + operation.setDescription(description); + operation.setImplementation(artifactDefinition); + operation.setInputs(inputs); + operation.setOutputs(outputs); + operation.setName(name); + Map<String, Operation> operationMap = new HashMap<>(); + operationMap.put(operation.getUniqueId(), operation); + InterfaceDefinition interfaceDefinition = new InterfaceDefinition(); + interfaceDefinition.setOperationsMap(operationMap); + return interfaceDefinition; + } + + private List<InputDefinition> createInputsForComponent(){ + InputDefinition inputDefinition1 = new InputDefinition(); + inputDefinition1.setName(inputId); + inputDefinition1.setInputId(inputId); + inputDefinition1.setUniqueId(inputId); + inputDefinition1.setValue(inputId); + inputDefinition1.setDefaultValue(inputId); + + InputDefinition inputDefinition2 = new InputDefinition(); + inputDefinition2.setName(outputId); + inputDefinition2.setInputId(outputId); + inputDefinition2.setUniqueId(outputId); + inputDefinition2.setValue(outputId); + inputDefinition2.setDefaultValue(outputId); + + return Arrays.asList(inputDefinition1, inputDefinition2); } private class InterfaceOperationValidationUtilTest extends InterfaceOperationValidation { diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverterTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverterTest.java deleted file mode 100644 index 0c02e71bd2..0000000000 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/datamodel/utils/InterfaceUIDataConverterTest.java +++ /dev/null @@ -1,104 +0,0 @@ -package org.openecomp.sdc.be.datamodel.utils; - -import org.junit.Assert; -import org.junit.Test; -import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.InterfaceOperationParamDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; -import org.openecomp.sdc.be.datatypes.elements.OperationInputDefinition; -import org.openecomp.sdc.be.datatypes.elements.OperationOutputDefinition; -import org.openecomp.sdc.be.model.Operation; - -import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperationInputDefinition; -import static org.openecomp.sdc.test.utils.InterfaceOperationTestUtils.createMockOperationOutputDefinition; - -public class InterfaceUIDataConverterTest { - - @Test - public void testConvertInterfaceDataToOperationData() { - InterfaceOperationDataDefinition interfaceOperation = createIODD("test", - "test description", - createParamDataList("inpName", "property", true, "String"), - createParamDataList("OutName", null, true, "String"), - "workflowId", - "workflowVersionId"); - Operation result; - result = InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperation); - Assert.assertNotNull(result); - } - - @Test - public void testConvertInterfaceDataToOperationDataWithoutMandatory() { - ListDataDefinition<InterfaceOperationParamDataDefinition> iopd = new ListDataDefinition<>(); - iopd.add(createParamData("test", "property", "String")); - InterfaceOperationDataDefinition interfaceOperation = createIODD("test", - "test description", iopd, iopd, - "workflowId", - "workflowVersionId"); - Operation result; - result = InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperation); - Assert.assertNotNull(result); - } - - @Test - public void testConvertInterfaceDataToOperationDataWithoutOptionalFields() { - InterfaceOperationDataDefinition interfaceOperation = new InterfaceOperationDataDefinition(); - interfaceOperation.setOperationType("operationType"); - Operation result; - result = InterfaceUIDataConverter.convertInterfaceDataToOperationData(interfaceOperation); - Assert.assertNotNull(result); - } - - @Test - public void testConvertOperationDataToInterfaceData() { - Operation operationData = new Operation(); - InterfaceOperationDataDefinition result; - ListDataDefinition<OperationInputDefinition> inputs = new ListDataDefinition<>(); - inputs.add(createMockOperationInputDefinition("Inp1")); - ListDataDefinition<OperationOutputDefinition> outputs = new ListDataDefinition<>(); - outputs.add(createMockOperationOutputDefinition("out1")); - operationData.setInputs(inputs); - operationData.setOutputs(outputs); - operationData.setImplementation(new ArtifactDataDefinition()); - result = InterfaceUIDataConverter.convertOperationDataToInterfaceData(operationData); - Assert.assertNotNull(result); - } - - private InterfaceOperationDataDefinition createIODD(String operationType, String description, - ListDataDefinition<InterfaceOperationParamDataDefinition> inputParams, - ListDataDefinition<InterfaceOperationParamDataDefinition> outputParams, - String workflowId, - String workflowVersionId) { - InterfaceOperationDataDefinition interfaceOperation = new InterfaceOperationDataDefinition(); - interfaceOperation.setOperationType(operationType); - interfaceOperation.setDescription(description); - interfaceOperation.setInputParams(inputParams); - interfaceOperation.setOutputParams(outputParams); - interfaceOperation.setWorkflowId(workflowId); - interfaceOperation.setWorkflowVersionId(workflowVersionId); - return interfaceOperation; - } - - private InterfaceOperationParamDataDefinition createParamData(String name, String property, boolean mandatory, String type) { - InterfaceOperationParamDataDefinition definition = createParamData(name, property, type); - definition.setMandatory(mandatory); - return definition; - } - - private InterfaceOperationParamDataDefinition createParamData(String name, String property, String type) { - InterfaceOperationParamDataDefinition definition = new InterfaceOperationParamDataDefinition(); - definition.setName(name); - definition.setProperty(property); - definition.setType(type); - return definition; - } - - private ListDataDefinition<InterfaceOperationParamDataDefinition> createParamDataList(String name, - String property, boolean mandatory, String type) { - ListDataDefinition<InterfaceOperationParamDataDefinition> list = new ListDataDefinition<>(); - list.add(createParamData(name, property, mandatory, type)); - return list; - } - -}
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java index 2fabe43733..592d27ec5d 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java @@ -1,6 +1,7 @@ package org.openecomp.sdc.be.tosca; import java.util.ArrayList; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -46,6 +47,7 @@ import org.openecomp.sdc.be.model.category.CategoryDefinition; import org.openecomp.sdc.be.model.category.SubCategoryDefinition; import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; import org.openecomp.sdc.be.tosca.model.SubstitutionMapping; import org.openecomp.sdc.be.tosca.model.ToscaCapability; import org.openecomp.sdc.be.tosca.model.ToscaMetadata; @@ -82,6 +84,9 @@ public class ToscaExportHandlerTest extends BeConfDependentTest { @Mock GroupExportParserImpl groupExportParserImpl; + @Mock + InterfaceLifecycleOperation interfaceLifecycleOperation; + @Before public void setUpMock() throws Exception { MockitoAnnotations.initMocks(this); @@ -160,7 +165,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest { ((Resource) component).setInterfaces(new HashMap<>()); Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); - + Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); // default test when convertInterfaceNodeType is right result = testSubject.exportComponentInterface(component, false); @@ -392,6 +397,7 @@ public class ToscaExportHandlerTest extends BeConfDependentTest { component.setInputs(inputs); Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>())); + Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap())); Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class), Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java index 8f34e0e29b..983ef91a8c 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/utils/InterfacesOperationsToscaUtilTest.java @@ -19,6 +19,7 @@ package org.openecomp.sdc.be.tosca.utils; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; +import java.util.ArrayList; import java.util.HashMap; import java.util.Map; @@ -63,15 +64,15 @@ public class InterfacesOperationsToscaUtilTest { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setToscaResourceName("interface.types.test_resource_name"); + addedInterface.setType("interface.types.test_resource_name"); addOperationsToInterface(addedInterface, 5, 3, true); final String interfaceType = "normalizedComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); final Map<String, Object> interfaceTypeElement = - InterfacesOperationsToscaUtil.addInterfaceTypeElement(component); + InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>()); - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null); + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("test"); template.setInterface_types(interfaceTypeElement); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); @@ -85,15 +86,15 @@ public class InterfacesOperationsToscaUtilTest { Component component = new Service(); component.setNormalizedName("normalizedServiceComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setToscaResourceName("interface.types.test_service_name"); + addedInterface.setType("interface.types.test_service_name"); addOperationsToInterface(addedInterface, 5, 3, true); final String interfaceType = "normalizedServiceComponentName-interface"; component.setInterfaces(new HashMap<>()); component.getInterfaces().put(interfaceType, addedInterface); final Map<String, Object> interfaceTypeElement = - InterfacesOperationsToscaUtil.addInterfaceTypeElement(component); + InterfacesOperationsToscaUtil.addInterfaceTypeElement(component, new ArrayList<>()); - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null); + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("testService"); template.setInterface_types(interfaceTypeElement); final ToscaRepresentation toscaRepresentation = handler.createToscaRepresentation(template); @@ -107,7 +108,7 @@ public class InterfacesOperationsToscaUtilTest { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setToscaResourceName("com.some.resource.or.other.resourceName"); + addedInterface.setType("com.some.resource.or.other.resourceName"); addOperationsToInterface(addedInterface, 3, 2, true); final String interfaceType = "normalizedComponentName-interface"; @@ -116,7 +117,7 @@ public class InterfacesOperationsToscaUtilTest { ToscaNodeType nodeType = new ToscaNodeType(); InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false); - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null); + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate(NODE_TYPE_NAME); Map<String, ToscaNodeType> nodeTypes = new HashMap<>(); nodeTypes.put(NODE_TYPE_NAME, nodeType); @@ -139,8 +140,7 @@ public class InterfacesOperationsToscaUtilTest { Component component = new Service(); component.setNormalizedName("normalizedServiceComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setToscaResourceName("com.some.service.or.other.serviceName"); - + addedInterface.setType("com.some.service.or.other.serviceName"); addOperationsToInterface(addedInterface, 3, 2, true); final String interfaceType = "normalizedServiceComponentName-interface"; component.setInterfaces(new HashMap<>()); @@ -148,7 +148,7 @@ public class InterfacesOperationsToscaUtilTest { ToscaNodeType nodeType = new ToscaNodeType(); InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false); - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null); + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("testService"); Map<String, ToscaNodeType> nodeTypes = new HashMap<>(); nodeTypes.put(NODE_TYPE_NAME, nodeType); @@ -170,8 +170,7 @@ public class InterfacesOperationsToscaUtilTest { Component component = new Resource(); component.setNormalizedName("normalizedComponentName"); InterfaceDefinition addedInterface = new InterfaceDefinition(); - addedInterface.setToscaResourceName("com.some.resource.or.other.resourceNameNoInputs"); - + addedInterface.setType("com.some.resource.or.other.resourceNameNoInputs"); addOperationsToInterface(addedInterface, 3, 3, false); final String interfaceType = "normalizedComponentName-interface"; component.setInterfaces(new HashMap<>()); @@ -179,7 +178,7 @@ public class InterfacesOperationsToscaUtilTest { ToscaNodeType nodeType = new ToscaNodeType(); InterfacesOperationsToscaUtil.addInterfaceDefinitionElement(component, nodeType, false); - ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null); + ToscaExportHandler handler = new ToscaExportHandler(null,null,null,null,null,null, null); ToscaTemplate template = new ToscaTemplate("test"); Map<String, ToscaNodeType> nodeTypes = new HashMap<>(); nodeTypes.put("test", nodeType); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java b/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java index 10acd69a79..4bda41671d 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/test/utils/InterfaceOperationTestUtils.java @@ -27,7 +27,7 @@ import org.openecomp.sdc.be.model.Operation; public class InterfaceOperationTestUtils { - public static InterfaceDefinition createInterface(String uniqueID, String description, String type, + private static InterfaceDefinition createInterface(String uniqueID, String description, String type, String toscaResourceName, Map<String, Operation> op) { InterfaceDefinition id = new InterfaceDefinition(); id.setType(type); @@ -38,48 +38,35 @@ public class InterfaceOperationTestUtils { return id; } - public static Operation createInterfaceOperation(String uniqueID, String description, ArtifactDefinition artifactDefinition, - ListDataDefinition<OperationInputDefinition> inputs, - ListDataDefinition<OperationOutputDefinition> outputs, String name) { - Operation operation = new Operation(); - operation.setUniqueId(uniqueID); - operation.setDescription(description); - operation.setImplementation(artifactDefinition); - operation.setInputs(inputs); - operation.setOutputs(outputs); - operation.setName(name); - return operation; - } - - public static InterfaceDefinition mockInterfaceDefinitionToReturn(String resourceName) { - Map<String, Operation> operationMap = createMockOperationMap(); - return createInterface("int1", "Interface 1", - "lifecycle", "org.openecomp.interfaces.node.lifecycle." + resourceName, operationMap); + public static Map<String, InterfaceDefinition> createMockInterfaceDefinitionMap(String interfaceId, String operationId) { + Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>(); + interfaceDefinitionMap.put(interfaceId, createMockInterface(interfaceId, operationId)); + return interfaceDefinitionMap; } - public static Operation mockOperationToReturn() { - return createMockOperation(); + public static InterfaceDefinition createMockInterface(String interfaceId, String operationId) { + return createInterface(interfaceId, interfaceId, interfaceId, interfaceId, createMockOperationMap(operationId)); } - public static Map<String, Operation> createMockOperationMap() { + public static Map<String, Operation> createMockOperationMap(String operationId) { Map<String, Operation> operationMap = new HashMap<>(); - operationMap.put("op1", createMockOperation()); + operationMap.put(operationId, createMockOperation(operationId)); return operationMap; } - public static Operation createMockOperation() { + public static Operation createMockOperation(String operationId) { Operation operation = new Operation(); ListDataDefinition<OperationInputDefinition> operationInputDefinitionList = new ListDataDefinition<>(); - operationInputDefinitionList.add(createMockOperationInputDefinition("label1")); + operationInputDefinitionList.add(createMockOperationInputDefinition("inputId")); operation.setInputs(operationInputDefinitionList); ListDataDefinition<OperationOutputDefinition> operationOutputDefList = new ListDataDefinition<>(); - operationOutputDefList.add(createMockOperationOutputDefinition("op1")); + operationOutputDefList.add(createMockOperationOutputDefinition("outputId")); operation.setOutputs(operationOutputDefList); operation.setDefinition(false); - operation.setName("CREATE"); - operation.setUniqueId("uniqueId1"); + operation.setName(operationId); + operation.setUniqueId(operationId); ArtifactDefinition implementation = new ArtifactDefinition(); implementation.setUniqueId("uniqId"); implementation.setArtifactUUID("artifactId"); @@ -89,28 +76,39 @@ public class InterfaceOperationTestUtils { return operation; } - public static OperationInputDefinition createMockOperationInputDefinition(String name) { + public static OperationInputDefinition createMockOperationInputDefinition(String inputId) { OperationInputDefinition operationInputDefinition = new OperationInputDefinition(); - operationInputDefinition.setName(name); - operationInputDefinition.setUniqueId("uniqueId1"); - operationInputDefinition.setInputId("inputId1"); + operationInputDefinition.setName(inputId); + operationInputDefinition.setUniqueId(inputId); + operationInputDefinition.setInputId(inputId); + operationInputDefinition.setValue(inputId); + operationInputDefinition.setDefaultValue(inputId); return operationInputDefinition; } - public static OperationOutputDefinition createMockOperationOutputDefinition(String name) { + public static OperationOutputDefinition createMockOperationOutputDefinition(String outputId) { OperationOutputDefinition operationOutputDefinition = new OperationOutputDefinition(); - operationOutputDefinition.setName(name); - operationOutputDefinition.setUniqueId("uniqueId1"); - operationOutputDefinition.setInputId("inputId1"); + operationOutputDefinition.setName(outputId); + operationOutputDefinition.setUniqueId(outputId); + operationOutputDefinition.setInputId(outputId); + operationOutputDefinition.setValue(outputId); + operationOutputDefinition.setDefaultValue(outputId); return operationOutputDefinition; } - public static Map<String, InterfaceDefinition> createMockInterfaceDefinition(String resourceName) { - Map<String, Operation> operationMap = createMockOperationMap(); + public static Map<String, InterfaceDefinition> createMockInterfaceTypeMap(String interfaceType, String operationType) { + Map<String, Operation> operationMap = createMockOperationTypeMap(operationType); Map<String, InterfaceDefinition> interfaceDefinitionMap = new HashMap<>(); - interfaceDefinitionMap.put("int1", createInterface("int1", "Interface 1", - "lifecycle", "org.openecomp.interfaces.node.lifecycle." + resourceName, operationMap)); + interfaceDefinitionMap.put(interfaceType, createInterface(interfaceType, interfaceType, interfaceType, interfaceType, operationMap)); return interfaceDefinitionMap; } + private static Map<String, Operation> createMockOperationTypeMap(String operationType) { + Operation operation = new Operation(); + operation.setUniqueId(operationType); + Map<String, Operation> operationMap = new HashMap<>(); + operationMap.put(operationType, operation); + return operationMap; + } + } |