diff options
12 files changed, 246 insertions, 21 deletions
diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java index 453564e2f8..02e64334f9 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/BaseBusinessLogic.java @@ -45,6 +45,7 @@ import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade; import org.openecomp.sdc.be.model.operations.StorageException; import org.openecomp.sdc.be.model.operations.api.*; import org.openecomp.sdc.be.model.operations.impl.DaoStatusConverter; +import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; import org.openecomp.sdc.be.model.operations.impl.PolicyTypeOperation; import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; import org.openecomp.sdc.be.model.operations.utils.ComponentValidationUtils; @@ -129,6 +130,9 @@ public abstract class BaseBusinessLogic { @Autowired protected InterfaceOperationBusinessLogic interfaceOperationBusinessLogic; + @Autowired + protected InterfaceLifecycleOperation interfaceLifecycleOperation; + @javax.annotation.Resource private UserValidations userValidations; @@ -171,6 +175,10 @@ public abstract class BaseBusinessLogic { } + public void setInterfaceLifecycleOperation(InterfaceLifecycleOperation interfaceLifecycleOperation) { + this.interfaceLifecycleOperation = interfaceLifecycleOperation; + } + User validateUserNotEmpty(User user, String ecompErrorContext) { return userValidations.validateUserNotEmpty(user, ecompErrorContext); } diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java index fed2cac518..a0efddbdda 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/components/impl/InterfaceOperationBusinessLogic.java @@ -41,6 +41,7 @@ import java.util.Collections; import java.util.Map; import java.util.Optional; import java.util.UUID; +import java.util.stream.Collectors; @Component("interfaceOperationBusinessLogic") public class InterfaceOperationBusinessLogic extends BaseBusinessLogic { @@ -324,4 +325,16 @@ public class InterfaceOperationBusinessLogic extends BaseBusinessLogic { } return Either.left( interfaceDefinition); } + + public Either<Map<String, InterfaceDefinition>, ResponseFormat> getAllInterfaceLifecycleTypes() { + + Either<Map<String, InterfaceDefinition>, StorageOperationStatus> interfaceLifecycleTypes = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(); + if(interfaceLifecycleTypes.isRight()) { + return Either.right(componentsUtils.getResponseFormat(ActionStatus.INTERFACE_LIFECYCLE_TYPES_NOT_FOUND)); + } + interfaceLifecycleTypes.left().value().values().stream().forEach( + id -> id.setOperations(id.getOperations().keySet().stream().collect(Collectors.toMap(key -> key.replaceFirst(id.getUniqueId()+".",""), i -> id.getOperations().get(i))))); + + return Either.left(interfaceLifecycleTypes.left().value()); + } } diff --git a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/TypesFetchServlet.java b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/TypesFetchServlet.java index 8bb93a7d3d..ddb405779d 100644 --- a/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/TypesFetchServlet.java +++ b/catalog-be/src/main/java/org/openecomp/sdc/be/servlets/TypesFetchServlet.java @@ -26,11 +26,13 @@ import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiResponse; import io.swagger.annotations.ApiResponses; +import org.openecomp.sdc.be.components.impl.InterfaceOperationBusinessLogic; import org.openecomp.sdc.be.components.impl.PropertyBusinessLogic; import org.openecomp.sdc.be.config.BeEcompErrorManager; import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.impl.WebAppContextWrapper; import org.openecomp.sdc.be.model.DataTypeDefinition; +import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.User; import org.openecomp.sdc.common.api.Constants; import org.openecomp.sdc.common.datastructure.Wrapper; @@ -109,4 +111,53 @@ public class TypesFetchServlet extends AbstractValidationsServlet { return webApplicationContext.getBean(PropertyBusinessLogic.class); } + @GET + @Path("interfaceLifecycleTypes") + @Consumes(MediaType.APPLICATION_JSON) + @Produces(MediaType.APPLICATION_JSON) + @ApiOperation(value = "Get interface lifecycle types", httpMethod = "GET", notes = "Returns interface lifecycle types", response = Response.class) + @ApiResponses(value = { + @ApiResponse(code = 200, message = "Interface lifecycle types"), + @ApiResponse(code = 403, message = "Restricted operation"), + @ApiResponse(code = 400, message = "Invalid content / Missing content"), + @ApiResponse(code = 404, message = "Interface lifecycle types not found") + }) + public Response getInterfaceLifecycleTypes(@Context final HttpServletRequest request, @HeaderParam(value = Constants.USER_ID_HEADER) String userId) { + + Wrapper<Response> responseWrapper = new Wrapper<>(); + Wrapper<User> userWrapper = new Wrapper<>(); + ServletContext context = request.getSession().getServletContext(); + + try { + validateUserExist(responseWrapper, userWrapper, userId); + + if (responseWrapper.isEmpty()) { + String url = request.getMethod() + " " + request.getRequestURI(); + log.info("Start handle request of {} | modifier id is {}", url, userId); + + InterfaceOperationBusinessLogic businessLogic = getInterfaceOperationBL(context); + Either<Map<String, InterfaceDefinition>, ResponseFormat> allInterfaceLifecycleTypes = + businessLogic.getAllInterfaceLifecycleTypes(); + + if (allInterfaceLifecycleTypes.isRight()) { + log.info("Failed to get all interface lifecycle types. Reason - {}", + allInterfaceLifecycleTypes.right().value()); + Response errorResponse = buildErrorResponse(allInterfaceLifecycleTypes.right().value()); + responseWrapper.setInnerElement(errorResponse); + + } else { + String interfaceLifecycleTypeJson = gson.toJson(allInterfaceLifecycleTypes.left().value()); + Response okResponse = buildOkResponse(getComponentsUtils().getResponseFormat(ActionStatus.OK), interfaceLifecycleTypeJson); + responseWrapper.setInnerElement(okResponse); + + } + } + + return responseWrapper.getInnerElement(); + } catch (Exception e) { + log.debug("get all interface lifecycle types failed with exception", e); + ResponseFormat responseFormat = getComponentsUtils().getResponseFormat(ActionStatus.GENERAL_ERROR); + return buildErrorResponse(responseFormat); + } + } } diff --git a/catalog-be/src/main/resources/config/error-configuration.yaml b/catalog-be/src/main/resources/config/error-configuration.yaml index aa000f14a7..84213bbe8d 100644 --- a/catalog-be/src/main/resources/config/error-configuration.yaml +++ b/catalog-be/src/main/resources/config/error-configuration.yaml @@ -2153,4 +2153,9 @@ errors: message: "Error: Interface operation output parameter name should not be empty.", messageId: "SVC4706" } - +#---------SVC4712----------------------------- + INTERFACE_LIFECYCLE_TYPES_NOT_FOUND: { + code: 404, + message: "Error: Interface Lifecycle types not found.", + messageId: "SVC4712" + }
\ No newline at end of file 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 4227e5d5cc..f2d8b57dbf 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 @@ -70,6 +70,7 @@ 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.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; @@ -106,6 +107,7 @@ public class InterfaceOperationBusinessLogicTest { 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; @@ -192,6 +194,7 @@ public class InterfaceOperationBusinessLogicTest { 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); @@ -423,6 +426,24 @@ public class InterfaceOperationBusinessLogicTest { return resource; } + @Test + public void testGetAllInterfaceLifecycleTypes_TypesNotFound() { + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + Either<Map<String, InterfaceDefinition>, ResponseFormat> response = bl.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); + 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(); + Assert.assertEquals(response.left().value().size(),1); + } }
\ No newline at end of file diff --git a/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java b/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java index e5caee5f01..fa96c45472 100644 --- a/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java +++ b/catalog-dao/src/main/java/org/openecomp/sdc/be/dao/api/ActionStatus.java @@ -121,6 +121,9 @@ public enum ActionStatus { INTERFACE_OPERATION_NOT_FOUND, INTERFACE_OPERATION_NAME_ALREADY_IN_USE, INTERFACE_OPERATION_NAME_MANDATORY, INTERFACE_OPERATION_NAME_INVALID, INTERFACE_OPERATION_DESCRIPTION_MAX_LENGTH, INTERFACE_OPERATION_INPUT_NAME_ALREADY_IN_USE, INTERFACE_OPERATION_OUTPUT_NAME_ALREADY_IN_USE,INTERFACE_OPERATION_NOT_DELETED, INTERFACE_OPERATION_INPUT_NAME_MANDATORY, INTERFACE_OPERATION_OUTPUT_NAME_MANDATORY, - INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT + INTERFACE_OPERATION_INPUT_PROPERTY_NOT_FOUND_IN_COMPONENT, + + //InterfaceLifeCycleType + INTERFACE_LIFECYCLE_TYPES_NOT_FOUND ; } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInterfaceLifecycleOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInterfaceLifecycleOperation.java index fd9addd0ec..06622ebba6 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInterfaceLifecycleOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/api/IInterfaceLifecycleOperation.java @@ -50,4 +50,6 @@ public interface IInterfaceLifecycleOperation { public Either<InterfaceDefinition, StorageOperationStatus> getInterface(String interfaceId); public String getShortInterfaceName(InterfaceDataDefinition interfaceDefinition); + + Either<Map<String, InterfaceDefinition>,StorageOperationStatus> getAllInterfaceLifecycleTypes(); } diff --git a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java index 3482a25bc4..c842e5b59d 100644 --- a/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java +++ b/catalog-model/src/main/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperation.java @@ -47,8 +47,8 @@ import java.util.*; import java.util.Map.Entry; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import java.util.Set; +import java.util.stream.Collectors; @Component("interface-operation") public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation { @@ -891,4 +891,40 @@ public class InterfaceLifecycleOperation implements IInterfaceLifecycleOperation return createInterfaceType(interf, false); } + @Override + public Either<Map<String, InterfaceDefinition>, StorageOperationStatus> getAllInterfaceLifecycleTypes() { + + Either<List<InterfaceData>, TitanOperationStatus> allInterfaceLifecycleTypes = + titanGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class); + if (allInterfaceLifecycleTypes.isRight()) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus + (allInterfaceLifecycleTypes.right().value())); + } + + Map<String, InterfaceDefinition> interfaceTypes = new HashMap<>(); + List<InterfaceData> interfaceDataList = allInterfaceLifecycleTypes.left().value(); + List<InterfaceDefinition> interfaceDefinitions = interfaceDataList.stream() + .map(this::convertInterfaceDataToInterfaceDefinition) + .filter(interfaceDefinition -> interfaceDefinition.getUniqueId().equalsIgnoreCase((interfaceDefinition.getType()))) + .collect(Collectors.toList()); + + for (InterfaceDefinition interfaceDefinition : interfaceDefinitions) { + + Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> + childrenNodes = titanGenericDao.getChildrenNodes(GraphPropertiesDictionary.UNIQUE_ID.getProperty(), + interfaceDefinition.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class); + if(childrenNodes.isRight()) { + return Either.right(DaoStatusConverter.convertTitanStatusToStorageStatus(childrenNodes.right().value())); + } + + Map<String, OperationDataDefinition> operationsDataDefinitionMap = new HashMap<>(); + for(ImmutablePair<OperationData, GraphEdge> operation : childrenNodes.left().value()) { + OperationData operationData = operation.getLeft(); + operationsDataDefinitionMap.put(operationData.getUniqueId(), operationData.getOperationDataDefinition()); + } + interfaceDefinition.setOperations(operationsDataDefinitionMap); + interfaceTypes.put(interfaceDefinition.getUniqueId(), interfaceDefinition); + } + return Either.left(interfaceTypes); + } } diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceOperationTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java index a50435b30c..3e8b087fb2 100644 --- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceOperationTest.java +++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/operations/impl/InterfaceLifecycleOperationTest.java @@ -22,44 +22,59 @@ package org.openecomp.sdc.be.model.operations.impl; import com.google.gson.Gson; import com.google.gson.GsonBuilder; +import fj.data.Either; +import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.openecomp.sdc.be.dao.graph.datatype.GraphEdge; +import org.openecomp.sdc.be.dao.neo4j.GraphEdgeLabels; import org.openecomp.sdc.be.dao.titan.TitanGenericDao; +import org.openecomp.sdc.be.dao.titan.TitanOperationStatus; import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition; import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum; import org.openecomp.sdc.be.model.ArtifactDefinition; import org.openecomp.sdc.be.model.InterfaceDefinition; import org.openecomp.sdc.be.model.ModelTestBase; import org.openecomp.sdc.be.model.Operation; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.util.OperationTestsUtil; +import org.openecomp.sdc.be.resources.data.category.CategoryData; +import org.openecomp.sdc.be.resources.data.InterfaceData; +import org.openecomp.sdc.be.resources.data.OperationData; import org.openecomp.sdc.be.resources.data.UserData; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import org.junit.Assert; + import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; + + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:application-context-test.xml") -public class InterfaceOperationTest { - private static final Logger log = LoggerFactory.getLogger(InterfaceOperationTest.class); +public class InterfaceLifecycleOperationTest { + private static final Logger log = LoggerFactory.getLogger(InterfaceLifecycleOperationTest.class); private Gson prettyGson = new GsonBuilder().setPrettyPrinting().create(); - private static String USER_ID = "muUserId"; private static String CATEGORY_NAME = "category/mycategory"; - // InterfaceLifecycleOperation interfaceOperation = new - // InterfaceLifecycleOperation(); - - // TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class); - @javax.annotation.Resource(name = "titan-generic-dao") - private TitanGenericDao titanDao; - @javax.annotation.Resource(name = "interface-operation") - private InterfaceLifecycleOperation interfaceOperation; + TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class); + @InjectMocks + private InterfaceLifecycleOperation interfaceLifecycleOperation = new InterfaceLifecycleOperation(); @javax.annotation.Resource(name = "property-operation") private PropertyOperation propertyOperation; @@ -69,6 +84,10 @@ public class InterfaceOperationTest { @Before public void createUserAndCategory() { + MockitoAnnotations.initMocks(this); + final String UNIQUE_ID = "UNIQUE_ID"; + CategoryData categoryData = new CategoryData(NodeTypeEnum.ResourceCategory); + when(titanGenericDao.createNode(any(),any())).thenReturn(Either.left(categoryData)); deleteAndCreateCategory(CATEGORY_NAME); deleteAndCreateUser(USER_ID, "first_" + USER_ID, "last_" + USER_ID); } @@ -88,7 +107,7 @@ public class InterfaceOperationTest { @Test public void testDummy() { - assertNotNull(interfaceOperation); + assertNotNull(interfaceLifecycleOperation); } @@ -228,7 +247,7 @@ public class InterfaceOperationTest { private void deleteAndCreateCategory(String category) { String[] names = category.split("/"); - OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanDao); + OperationTestsUtil.deleteAndCreateResourceCategory(names[0], names[1], titanGenericDao); /* * CategoryData categoryData = new CategoryData(); categoryData.setName(category); @@ -244,11 +263,40 @@ public class InterfaceOperationTest { userData.setFirstName(firstName); userData.setLastName(lastName); - titanDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, UserData.class); - titanDao.createNode(userData, UserData.class); - titanDao.commit(); + titanGenericDao.deleteNode(UniqueIdBuilder.getKeyByNodeType(NodeTypeEnum.User), userId, + UserData.class); + titanGenericDao.createNode(userData, UserData.class); + titanGenericDao.commit(); return userData; } + @Test + public void testGetAllInterfaceLifecycleTypes_TypesNotFound() { + when(titanGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), + InterfaceData.class)).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND)); + Either<Map<String, InterfaceDefinition>, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(); + Assert.assertEquals(types.isRight(), Boolean.TRUE); + } + + @Test + public void testGetAllInterfaceLifecycleTypes_Success() { + final String UNIQUE_ID = "UNIQUE_ID"; + final String TYPE = "UNIQUE_ID"; + InterfaceData interfaceData = new InterfaceData(); + interfaceData.getInterfaceDataDefinition().setUniqueId(UNIQUE_ID); + interfaceData.getInterfaceDataDefinition().setType(TYPE); + List<InterfaceData> interfaceDataList = new ArrayList<>(); + interfaceDataList.add(interfaceData); + Either<List<InterfaceData>, TitanOperationStatus> allInterfaceTypes = Either.left(interfaceDataList); + when(titanGenericDao.getByCriteria(NodeTypeEnum.Interface, Collections.emptyMap(), InterfaceData.class)).thenReturn(allInterfaceTypes); + + List<ImmutablePair<OperationData, GraphEdge>> list = new ArrayList<>(); + Either<List<ImmutablePair<OperationData, GraphEdge>>, TitanOperationStatus> childrenNodes = Either.left(list); + when(titanGenericDao.getChildrenNodes(interfaceData.getUniqueIdKey(), interfaceData.getUniqueId(), GraphEdgeLabels.INTERFACE_OPERATION, NodeTypeEnum.InterfaceOperation, OperationData.class)).thenReturn(childrenNodes); + + Either<Map<String, InterfaceDefinition>, StorageOperationStatus> types = interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(); + Assert.assertEquals(types.left().value().size(),1); + } + } diff --git a/openecomp-bdd/config.json b/openecomp-bdd/config.json index c28bc9d390..4bf5f95ac5 100644 --- a/openecomp-bdd/config.json +++ b/openecomp-bdd/config.json @@ -13,6 +13,12 @@ "server" : "vf.server", "user" : "user" }, + "catalog" : { + "port" : 8080, + "prefix" : "sdc2/rest/v1", + "server" : "CatalogBE.server", + "user" : "user" + }, "activity_spec" : { "port" : 8080, "prefix" : "activity-spec-api/v1.0", diff --git a/openecomp-bdd/features/GlobalTypes/TestInterfaceLifecycleTypes.feature b/openecomp-bdd/features/GlobalTypes/TestInterfaceLifecycleTypes.feature new file mode 100644 index 0000000000..ef98fa5b42 --- /dev/null +++ b/openecomp-bdd/features/GlobalTypes/TestInterfaceLifecycleTypes.feature @@ -0,0 +1,8 @@ +Feature: Interface Lifecycle Types + +Scenario: Test Interface Lifecycle Types + + When I want to get interface lifecycle types + Then I want to check property "tosca.interfaces.node.lifecycle.standard" exists + Then I want to check property "tosca.interfaces.nfv.vnf.lifecycle.nfv" exists + diff --git a/openecomp-bdd/stepDefinitions/GlobalTypes.js b/openecomp-bdd/stepDefinitions/GlobalTypes.js new file mode 100644 index 0000000000..461fee74a7 --- /dev/null +++ b/openecomp-bdd/stepDefinitions/GlobalTypes.js @@ -0,0 +1,24 @@ +/* + * Copyright © 2016-2018 European Support Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +const {Then, When} = require('cucumber'); +const assert = require('assert'); +const util = require('./Utils.js'); + +When('I want to get interface lifecycle types', function () { + let path = '/catalog/interfaceLifecycleTypes'; + return util.request(this.context, 'GET', path, null, false, 'catalog'); +});
\ No newline at end of file |