From a52d50e788792a63e97a9176ab319d53db7a2853 Mon Sep 17 00:00:00 2001 From: vempo Date: Tue, 24 Jul 2018 17:34:04 +0300 Subject: Replaced old implementation at root Old project files and directories has been moved under 'deprecated-workflow-designer'. The old project is not built by the CI anymore, but can be still built manually. New modules/directories have been moved up and integrated with the CI system. Change-Id: I1528c792bcbcce9e50bfc294a1328a20e72c91cf Issue-ID: SDC-1559 Signed-off-by: vempo --- .../main/java/org/onap/sdc/workflow/RestUtils.java | 31 +++ .../sdc/workflow/SpringBootWebApplication.java | 37 +++ .../org/onap/sdc/workflow/api/RestConstants.java | 31 +++ .../onap/sdc/workflow/api/WorkflowController.java | 119 +++++++++ .../workflow/api/WorkflowVersionController.java | 150 +++++++++++ .../CustomizedResponseEntityExceptionHandler.java | 97 +++++++ .../sdc/workflow/api/types/CollectionWrapper.java | 43 +++ .../sdc/workflow/api/types/VersionStateDto.java | 36 +++ .../api/validator/WorkflowVersionValidator.java | 61 +++++ .../workflow/persistence/ArtifactRepository.java | 34 +++ .../workflow/persistence/ParameterRepository.java | 39 +++ .../persistence/UniqueValueRepository.java | 26 ++ .../persistence/impl/ArtifactRepositoryImpl.java | 119 +++++++++ .../persistence/impl/ParameterRepositoryImpl.java | 180 +++++++++++++ .../workflow/persistence/types/ArtifactEntity.java | 32 +++ .../persistence/types/ParameterEntity.java | 34 +++ .../persistence/types/ParameterPropertyName.java | 23 ++ .../workflow/persistence/types/ParameterRole.java | 24 ++ .../workflow/persistence/types/ParameterType.java | 25 ++ .../persistence/types/UniqueValueEntity.java | 39 +++ .../sdc/workflow/persistence/types/Workflow.java | 39 +++ .../persistence/types/WorkflowElementType.java | 26 ++ .../persistence/types/WorkflowProperty.java | 25 ++ .../persistence/types/WorkflowVersion.java | 46 ++++ .../persistence/types/WorkflowVersionState.java | 36 +++ .../sdc/workflow/server/config/SwaggerConfig.java | 24 ++ .../sdc/workflow/server/config/ZusammenConfig.java | 32 +++ .../server/filters/SessionContextFilter.java | 64 +++++ .../sdc/workflow/services/UniqueValueService.java | 123 +++++++++ .../sdc/workflow/services/WorkflowManager.java | 34 +++ .../workflow/services/WorkflowNameComparator.java | 32 +++ .../workflow/services/WorkflowVersionManager.java | 46 ++++ .../exceptions/EntityNotFoundException.java | 24 ++ .../exceptions/InvalidArtifactException.java | 24 ++ .../InvalidPaginationParameterException.java | 24 ++ .../exceptions/UniqueValueViolationException.java | 27 ++ .../exceptions/VersionCreationException.java | 31 +++ .../exceptions/VersionModificationException.java | 26 ++ .../VersionStateModificationException.java | 28 ++ .../services/impl/CollaborationConfiguration.java | 38 +++ .../services/impl/WorkflowManagerImpl.java | 159 ++++++++++++ .../services/impl/WorkflowVersionManagerImpl.java | 277 ++++++++++++++++++++ .../services/impl/mappers/VersionMapper.java | 35 +++ .../services/impl/mappers/VersionStateMapper.java | 47 ++++ .../services/impl/mappers/WorkflowMapper.java | 38 +++ .../src/main/resources/application.properties | 10 + .../test/java/org/onap/sdc/workflow/RestPath.java | 66 +++++ .../test/java/org/onap/sdc/workflow/TestUtil.java | 35 +++ .../sdc/workflow/api/WorkflowControllerTest.java | 287 +++++++++++++++++++++ .../api/WorkflowVersionControllerTest.java | 117 +++++++++ .../persistence/impl/ArtifactRepositoryTest.java | 99 +++++++ .../persistence/impl/ParameterRepositoryTest.java | 166 ++++++++++++ .../workflow/services/UniqueValueServiceTest.java | 98 +++++++ .../services/impl/WorkflowManagerImplTest.java | 240 +++++++++++++++++ .../impl/WorkflowVersionManagerImplTest.java | 264 +++++++++++++++++++ .../services/impl/mappers/VersionMapperTest.java | 80 ++++++ .../impl/mappers/VersionStateMapperTest.java | 75 ++++++ .../services/impl/mappers/WorkflowMapperTest.java | 50 ++++ 58 files changed, 4072 insertions(+) create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java create mode 100644 workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java create mode 100644 workflow-designer-be/src/main/resources/application.properties create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java create mode 100644 workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java (limited to 'workflow-designer-be/src') diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java new file mode 100644 index 00000000..b6259ccc --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/RestUtils.java @@ -0,0 +1,31 @@ +package org.onap.sdc.workflow; + +import java.util.Arrays; +import java.util.Collections; +import java.util.Set; +import java.util.stream.Collectors; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; + +public class RestUtils { + + private RestUtils() { + } + + private static final Logger LOGGER = LoggerFactory.getLogger(RestUtils.class); + + public static Set mapVersionStateFilter(String versionStateFilter) { + Set filter; + try { + filter = versionStateFilter == null ? null : + Arrays.stream(versionStateFilter.split(",")).map(WorkflowVersionState::valueOf) + .collect(Collectors.toSet()); + } catch (Exception e) { + LOGGER.info( + "version state filter value is invalid and cannot be mapped to a set of version states, therefore it is set to empty set"); + filter = Collections.emptySet(); + } + return filter; + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java new file mode 100644 index 00000000..0feafd2a --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/SpringBootWebApplication.java @@ -0,0 +1,37 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.web.embedded.jetty.JettyServletWebServerFactory; +import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory; +import org.springframework.context.annotation.Bean; + +@SpringBootApplication +public class SpringBootWebApplication { + + public static void main(String[] args) { + SpringApplication.run(SpringBootWebApplication.class, args); + } + + @Bean + public ConfigurableServletWebServerFactory webServerFactory() { + return new JettyServletWebServerFactory(); + } + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java new file mode 100644 index 00000000..817bebe1 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/RestConstants.java @@ -0,0 +1,31 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api; + +public class RestConstants { + + private RestConstants() { + } + + public static final String USER_ID_HEADER_PARAM = "USER_ID"; + public static final String SIZE_PARAM = "size"; + public static final String PAGE_PARAM = "page"; + public static final String SORT_PARAM = "sort"; + public static final String SORT_FIELD_NAME = "name"; + public static final int SIZE_DEFAULT = 20; + public static final int PAGE_DEFAULT = 0; +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java new file mode 100644 index 00000000..7027985f --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowController.java @@ -0,0 +1,119 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api; + +import static org.onap.sdc.workflow.RestUtils.mapVersionStateFilter; +import static org.onap.sdc.workflow.api.RestConstants.SIZE_DEFAULT; +import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME; +import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM; +import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM; + +import com.google.common.collect.ImmutableSet; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import java.util.Arrays; +import java.util.Set; +import org.onap.sdc.workflow.api.types.CollectionWrapper; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.onap.sdc.workflow.services.WorkflowManager; +import org.onap.sdc.workflow.services.exceptions.InvalidPaginationParameterException; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Pageable; +import org.springframework.data.domain.Sort; +import org.springframework.data.web.PageableDefault; +import org.springframework.data.web.SortDefault; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +@RequestMapping("/workflows") +@Api("Workflows") +@RestController("workflowController") +public class WorkflowController { + + private final WorkflowManager workflowManager; + + @Autowired + public WorkflowController(@Qualifier("workflowManager") WorkflowManager workflowManager) { + this.workflowManager = workflowManager; + } + + @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE) + @ApiOperation("List workflows") + public CollectionWrapper list( + @ApiParam(value = "Filter by version state", allowableValues = "DRAFT,CERTIFIED") + @RequestParam(value = "versionState", required = false) String versionStateFilter, + @PageableDefault(size = SIZE_DEFAULT) + @SortDefault.SortDefaults({@SortDefault(sort = SORT_FIELD_NAME, direction = Sort.Direction.ASC)}) + Pageable pageable, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + PageRequest pageRequest = createPageRequest(pageable); + return new CollectionWrapper<>(pageRequest.getPageSize(), pageRequest.getPageNumber(), + workflowManager.list(mapVersionStateFilter(versionStateFilter), pageRequest)); + } + + @PostMapping(consumes = MediaType.APPLICATION_JSON_VALUE) + @ApiOperation("Create workflow") + public ResponseEntity create(@Validated @RequestBody Workflow workflow, + @RequestHeader(USER_ID_HEADER_PARAM) String user) { + return new ResponseEntity<>(workflowManager.create(workflow), HttpStatus.CREATED); + } + + @GetMapping(path = "/{workflowId}") + @ApiOperation("Get workflow") + public Workflow get(@PathVariable("workflowId") String workflowId, + @RequestHeader(USER_ID_HEADER_PARAM) String user) { + Workflow workflow = new Workflow(); + workflow.setId(workflowId); + return workflowManager.get(workflow); + } + + @PutMapping(path = "/{workflowId}", consumes = MediaType.APPLICATION_JSON_VALUE) + @ApiOperation("Update workflow") + public Workflow update(@RequestBody Workflow workflow, @PathVariable("workflowId") String workflowId, + @RequestHeader(USER_ID_HEADER_PARAM) String user) { + workflow.setId(workflowId); + workflowManager.update(workflow); + return workflow; + } + + + private PageRequest createPageRequest(Pageable pageable) { + Set validSortFields = ImmutableSet.of(SORT_FIELD_NAME); + Sort sort = pageable.getSort(); + for (Sort.Order order : sort) { + String sortFieldName = order.getProperty(); + if (!sortFieldName.equalsIgnoreCase(SORT_FIELD_NAME)) { + throw new InvalidPaginationParameterException(SORT_PARAM, sortFieldName, + "is not supported. Supported values are: " + Arrays.toString(validSortFields.toArray())); + } + } + return PageRequest.of(pageable.getPageNumber(), pageable.getPageSize(), sort); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java new file mode 100644 index 00000000..91995bd0 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/WorkflowVersionController.java @@ -0,0 +1,150 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api; + +import static org.onap.sdc.workflow.RestUtils.mapVersionStateFilter; +import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM; + +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import io.swagger.annotations.ApiParam; +import org.onap.sdc.workflow.api.types.CollectionWrapper; +import org.onap.sdc.workflow.api.types.VersionStateDto; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.onap.sdc.workflow.services.WorkflowVersionManager; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.core.io.InputStreamResource; +import org.springframework.core.io.Resource; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.Validator; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.WebDataBinder; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.InitBinder; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.multipart.MultipartFile; + +@RequestMapping("/workflows/{workflowId}/versions") +@Api("Workflow versions") +@RestController("workflowsVersionController") +public class WorkflowVersionController { + + private final WorkflowVersionManager workflowVersionManager; + private Validator validator; + + @InitBinder + private void initBinder(WebDataBinder binder) { + binder.addValidators(validator); + } + + @Autowired + public WorkflowVersionController( + @Qualifier("workflowVersionManager") WorkflowVersionManager workflowVersionManager, + @Qualifier("workflowVersionValidator") Validator validator ) { + this.workflowVersionManager = workflowVersionManager; + this.validator = validator; + } + + @GetMapping + @ApiOperation("List workflow versions") + public CollectionWrapper list(@PathVariable("workflowId") String workflowId, + @ApiParam(value = "Filter by state", allowableValues = "DRAFT,CERTIFIED") + @RequestParam(value = "state", required = false) String stateFilter, + @RequestHeader(USER_ID_HEADER_PARAM) String user) { + return new CollectionWrapper<>(workflowVersionManager.list(workflowId, mapVersionStateFilter(stateFilter))); + } + + @PostMapping + @ApiOperation("Create workflow version") + public ResponseEntity create(@RequestBody @Validated WorkflowVersion version, + @PathVariable("workflowId") String workflowId, + @RequestParam(value = "baseVersionId", required = false) String baseVersionId, + @RequestHeader(USER_ID_HEADER_PARAM) String user) { + WorkflowVersion createdVersion = workflowVersionManager.create(workflowId, baseVersionId, version); + return new ResponseEntity<>(createdVersion, HttpStatus.CREATED); + } + + @GetMapping("/{versionId}") + @ApiOperation("Get workflow version") + public WorkflowVersion get(@PathVariable("workflowId") String workflowId, + @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + return workflowVersionManager.get(workflowId, versionId); + } + + @PutMapping("/{versionId}") + @ApiOperation("Update workflow version") + public void update(@RequestBody @Validated WorkflowVersion version, @PathVariable("workflowId") String workflowId, + @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + version.setId(versionId); + workflowVersionManager.update(workflowId, version); + } + + @GetMapping("/{versionId}/state") + @ApiOperation("Get workflow version state") + public VersionStateDto getState(@PathVariable("workflowId") String workflowId, + @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + return new VersionStateDto(workflowVersionManager.getState(workflowId, versionId)); + } + + @PostMapping("/{versionId}/state") + @ApiOperation("Update workflow version state") + public VersionStateDto updateState(@RequestBody VersionStateDto state, + @PathVariable("workflowId") String workflowId, @PathVariable("versionId") String versionId, + @RequestHeader(USER_ID_HEADER_PARAM) String user) { + workflowVersionManager.updateState(workflowId, versionId, state.getName()); + return new VersionStateDto(state.getName()); + } + + @PutMapping("/{versionId}/artifact") + @ApiOperation("Create/update artifact of a version") + public void uploadArtifact(@RequestBody MultipartFile fileToUpload, @PathVariable("workflowId") String workflowId, + @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + workflowVersionManager.uploadArtifact(workflowId, versionId, fileToUpload); + } + + @GetMapping("/{versionId}/artifact") + @ApiOperation("Download workflow version artifact") + public ResponseEntity getArtifact(@PathVariable("workflowId") String workflowId, + @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + ArtifactEntity artifact = workflowVersionManager.getArtifact(workflowId, versionId); + + return ResponseEntity.ok() + .header(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + artifact.getFileName()) + .contentType(MediaType.APPLICATION_OCTET_STREAM) + .body(new InputStreamResource(artifact.getArtifactData())); + } + + @DeleteMapping("/{versionId}/artifact") + @ApiOperation("Delete workflow version artifact") + public void deleteArtifact(@PathVariable("workflowId") String workflowId, + @PathVariable("versionId") String versionId, @RequestHeader(USER_ID_HEADER_PARAM) String user) { + workflowVersionManager.deleteArtifact(workflowId, versionId); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java new file mode 100644 index 00000000..ca6111df --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/exceptionshandlers/CustomizedResponseEntityExceptionHandler.java @@ -0,0 +1,97 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api.exceptionshandlers; + +import static org.springframework.http.HttpStatus.BAD_REQUEST; +import static org.springframework.http.HttpStatus.FORBIDDEN; +import static org.springframework.http.HttpStatus.NOT_FOUND; +import static org.springframework.http.HttpStatus.UNPROCESSABLE_ENTITY; + +import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException; +import org.onap.sdc.workflow.services.exceptions.InvalidArtifactException; +import org.onap.sdc.workflow.services.exceptions.InvalidPaginationParameterException; +import org.onap.sdc.workflow.services.exceptions.UniqueValueViolationException; +import org.onap.sdc.workflow.services.exceptions.VersionCreationException; +import org.onap.sdc.workflow.services.exceptions.VersionModificationException; +import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.validation.FieldError; +import org.springframework.web.bind.MethodArgumentNotValidException; +import org.springframework.web.bind.ServletRequestBindingException; +import org.springframework.web.bind.annotation.ControllerAdvice; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.context.request.WebRequest; +import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler; + +@ControllerAdvice +@RestController +public class CustomizedResponseEntityExceptionHandler extends ResponseEntityExceptionHandler { + + @ExceptionHandler(UniqueValueViolationException.class) + public final ResponseEntity handleUniqueValueViolationException( + UniqueValueViolationException exception) { + return new ResponseEntity<>(exception.getMessage(), UNPROCESSABLE_ENTITY); + } + + @ExceptionHandler(EntityNotFoundException.class) + public final ResponseEntity handleWorkflowNotFoundException( + Exception exception) { + return new ResponseEntity<>(exception.getMessage(), NOT_FOUND); + } + + @ExceptionHandler({InvalidPaginationParameterException.class}) + public final ResponseEntity handlePaginationException(InvalidPaginationParameterException exception) { + return new ResponseEntity<>(exception.getMessage(), BAD_REQUEST); + } + + //For workflowVersionValidator exception + @Override + protected final ResponseEntity handleMethodArgumentNotValid(final MethodArgumentNotValidException e, + final HttpHeaders headers, + final HttpStatus status, + final WebRequest request) { + + FieldError result = e.getBindingResult().getFieldError(); + return new ResponseEntity<>(result.getDefaultMessage(), BAD_REQUEST); + } + + //For missing header exceptions + @Override + public ResponseEntity handleServletRequestBindingException(ServletRequestBindingException ex, + HttpHeaders headers, HttpStatus status, + WebRequest request) { + return new ResponseEntity<>(ex.getMessage(), BAD_REQUEST); + } + + + @ExceptionHandler({InvalidArtifactException.class, VersionModificationException.class, + VersionStateModificationException.class}) + public final ResponseEntity handleInvalidArtifactException( + Exception exception) { + return new ResponseEntity<>(exception.getMessage(), UNPROCESSABLE_ENTITY); + } + + + @ExceptionHandler(VersionCreationException.class) + public final ResponseEntity handleVersioningErrorException( + VersionCreationException exception) { + return new ResponseEntity<>(exception.getMessage(), FORBIDDEN); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java new file mode 100644 index 00000000..1e11bc90 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/CollectionWrapper.java @@ -0,0 +1,43 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api.types; + +import java.util.Collection; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +public class CollectionWrapper { + + private int total; + private int size; + private int page; + private Collection results; + + public CollectionWrapper(int size, int page, Collection results) { + this.results = results; + this.size = size; + this.page = page; + this.total = results.size(); + } + + public CollectionWrapper(Collection results) { + this.results = results; + this.total = results.size(); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java new file mode 100644 index 00000000..a7f43cdd --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/types/VersionStateDto.java @@ -0,0 +1,36 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api.types; + +import java.util.List; +import lombok.Data; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; + +@Data +public class VersionStateDto { + + private WorkflowVersionState name; + private List nextStates; + + public VersionStateDto() { + } + + public VersionStateDto(WorkflowVersionState state) { + name = state; + nextStates = state.getNextStates(); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java new file mode 100644 index 00000000..03101042 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/api/validator/WorkflowVersionValidator.java @@ -0,0 +1,61 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.api.validator; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Objects; +import java.util.Set; +import org.onap.sdc.workflow.persistence.types.ParameterEntity; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.springframework.stereotype.Component; +import org.springframework.validation.Errors; +import org.springframework.validation.Validator; + + +@Component("workflowVersionValidator") +public class WorkflowVersionValidator implements Validator{ + + @Override + public boolean supports(Class aClass) { + return WorkflowVersion.class.equals(aClass); + } + + @Override + public void validate(Object o, Errors errors) { + + WorkflowVersion workflowVersion = (WorkflowVersion) o; + Collection inputs = workflowVersion.getInputs(); + Collection outputs = workflowVersion.getOutputs(); + + if(containsDuplicates(inputs)){ + errors.rejectValue("inputs", "duplicateName", new Object[] {inputs}, "Input name must be unique"); + } + + if(containsDuplicates(outputs)){ + errors.rejectValue("outputs", "duplicateName", new Object[] {outputs}, "Output name must be unique"); + } + } + + private boolean containsDuplicates(Collection parameters){ + if(Objects.isNull(parameters) || parameters.size() < 2 ) { + return false; + } + Set testSet = new HashSet<>(); + return parameters.stream().anyMatch(s -> !testSet.add(s.getName())); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java new file mode 100644 index 00000000..ed9371e6 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ArtifactRepository.java @@ -0,0 +1,34 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence; + + +import java.util.Optional; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; + + +public interface ArtifactRepository { + + void update(String id, String versionId,ArtifactEntity artifactEntity); + + Optional get(String id, String versionId); + + void createStructure(String id, String versionId); + + void delete(String id, String versionId); + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java new file mode 100644 index 00000000..9f7fb1ad --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/ParameterRepository.java @@ -0,0 +1,39 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence; + +import java.util.Collection; +import org.onap.sdc.workflow.persistence.types.ParameterEntity; +import org.onap.sdc.workflow.persistence.types.ParameterRole; + + +public interface ParameterRepository { + + void createStructure(String id, String versionId); + + Collection list(String id, String versionId, ParameterRole role); + + void deleteAll(String id, String versionId, ParameterRole role); + + ParameterEntity get(String id, String versionId, String parameterId); + + void delete(String id, String versionId, String parameterId); + + ParameterEntity create(String id, String versionId , ParameterRole role, ParameterEntity parameter); + + void update(String id, String versionId, ParameterRole role, ParameterEntity parameter); +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java new file mode 100644 index 00000000..cf7b0633 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/UniqueValueRepository.java @@ -0,0 +1,26 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence; + +import org.onap.sdc.workflow.persistence.types.UniqueValueEntity; +import org.springframework.data.cassandra.repository.CassandraRepository; +import org.springframework.stereotype.Repository; + +@Repository +public interface UniqueValueRepository extends CassandraRepository { + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java new file mode 100644 index 00000000..3c528db1 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryImpl.java @@ -0,0 +1,119 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.impl; + +import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement; +import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext; + +import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement; +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.item.Action; +import com.amdocs.zusammen.datatypes.item.ElementContext; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.Arrays; +import java.util.Optional; +import org.apache.commons.io.IOUtils; +import org.onap.sdc.workflow.persistence.ArtifactRepository; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; +import org.onap.sdc.workflow.persistence.types.WorkflowElementType; +import org.openecomp.core.zusammen.api.ZusammenAdaptor; +import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory; +import org.springframework.stereotype.Repository; + +@Repository +public class ArtifactRepositoryImpl implements ArtifactRepository { + + private static final String FILE_NAME_PROPERTY = "fileName"; + private static final String EMPTY_DATA = "{}"; + private ZusammenAdaptor zusammenAdaptor = ZusammenAdaptorFactory.getInstance().createInterface(); + + + @Override + public void update(String id, String versionId, ArtifactEntity artifactEntity) { + + ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.UPDATE); + artifactElement.setData(artifactEntity.getArtifactData()); + artifactElement.getInfo().addProperty(FILE_NAME_PROPERTY, artifactEntity.getFileName()); + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + zusammenAdaptor + .saveElement(context, elementContext, artifactElement, "Update WorkflowVersion Artifact Element"); + } + + @Override + public Optional get(String id, String versionId) { + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + Optional elementOptional = + zusammenAdaptor.getElementByName(context, elementContext, null, WorkflowElementType.ARTIFACT.name()); + + if (!elementOptional.isPresent() || hasEmptyData(elementOptional.get().getData())) { + return Optional.empty(); + } + + Element artifactElement = elementOptional.get(); + + ArtifactEntity artifact = new ArtifactEntity(artifactElement.getInfo().getProperty(FILE_NAME_PROPERTY), + artifactElement.getData()); + + return Optional.of(artifact); + } + + @Override + public void createStructure(String id, String versionId) { + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.CREATE); + artifactElement.setData(new ByteArrayInputStream(EMPTY_DATA.getBytes())); + + zusammenAdaptor + .saveElement(context, elementContext, artifactElement, "Create WorkflowVersion Artifact Element"); + + } + + @Override + public void delete(String id, String versionId) { + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.UPDATE); + artifactElement.setData(new ByteArrayInputStream(EMPTY_DATA.getBytes())); + artifactElement.getInfo().getProperties().remove(FILE_NAME_PROPERTY); + + zusammenAdaptor + .saveElement(context, elementContext, artifactElement, "Delete WorkflowVersion Artifact Data"); + + } + + private boolean hasEmptyData(InputStream elementData) { + + byte[] byteElementData; + try { + byteElementData = IOUtils.toByteArray(elementData); + } catch (IOException ex) { + return false; + } + return Arrays.equals(EMPTY_DATA.getBytes(), byteElementData); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java new file mode 100644 index 00000000..468e93fe --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryImpl.java @@ -0,0 +1,180 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.impl; + +import static org.openecomp.core.zusammen.api.ZusammenUtil.buildElement; +import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement; +import static org.openecomp.core.zusammen.api.ZusammenUtil.createSessionContext; + +import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement; +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.item.Action; +import com.amdocs.zusammen.datatypes.item.ElementContext; +import com.amdocs.zusammen.datatypes.item.Info; +import java.util.Collection; +import java.util.Optional; +import java.util.stream.Collectors; +import org.onap.sdc.workflow.persistence.ParameterRepository; +import org.onap.sdc.workflow.persistence.types.ParameterEntity; +import org.onap.sdc.workflow.persistence.types.ParameterPropertyName; +import org.onap.sdc.workflow.persistence.types.ParameterRole; +import org.onap.sdc.workflow.persistence.types.ParameterType; +import org.onap.sdc.workflow.persistence.types.WorkflowElementType; +import org.openecomp.core.zusammen.api.ZusammenAdaptor; +import org.openecomp.core.zusammen.api.ZusammenAdaptorFactory; +import org.openecomp.types.ElementPropertyName; +import org.springframework.stereotype.Repository; + +@Repository +public class ParameterRepositoryImpl implements ParameterRepository { + + private ZusammenAdaptor zusammenAdaptor = ZusammenAdaptorFactory.getInstance().createInterface(); + + @Override + public void createStructure(String id, String versionId) { + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + ZusammenElement inputsElement = buildStructuralElement(WorkflowElementType.INPUTS.name(), Action.CREATE); + ZusammenElement outputsElement = buildStructuralElement(WorkflowElementType.OUTPUTS.name(), Action.CREATE); + + zusammenAdaptor.saveElement(context, elementContext, inputsElement, "Create WorkflowVersion INPUTS Element"); + zusammenAdaptor.saveElement(context, elementContext, outputsElement, "Create WorkflowVersion OUTPUTS Element"); + } + + @Override + public Collection list(String id, String versionId, ParameterRole role) { + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + return zusammenAdaptor.listElementsByName(context, elementContext, null, getParentElementType(role)).stream() + .map(this::mapElementInfoToParameter).collect(Collectors.toList()); + + } + + @Override + public void deleteAll(String id, String versionId, ParameterRole role) { + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + Optional optionalParentElement = + zusammenAdaptor.getElementInfoByName(context, elementContext, null, getParentElementType(role)); + + if (!optionalParentElement.isPresent()) { + return; + } + ZusammenElement parentElement = buildElement(optionalParentElement.get().getId(), Action.IGNORE); + parentElement.setSubElements(optionalParentElement.get().getSubElements().stream() + .map(parameter -> buildElement(parameter.getId(), + Action.DELETE)).collect(Collectors.toList())); + + zusammenAdaptor.saveElement(context, elementContext, parentElement, "Delete all " + role); + } + + @Override + public ParameterEntity get(String id, String versionId, String parameterId) { + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + Optional element = zusammenAdaptor.getElementInfo(context, elementContext, new Id(parameterId)); + + return element.map(this::mapElementInfoToParameter).orElse(null); + } + + @Override + public void delete(String id, String versionId, String parameterId) { + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + ZusammenElement parameterElement = buildElement(new Id(parameterId), Action.DELETE); + + zusammenAdaptor.saveElement(context, elementContext, parameterElement, + String.format("Delete Parameter with id %s", parameterId)); + + } + + @Override + public ParameterEntity create(String id, String versionId, ParameterRole role, ParameterEntity parameter) { + + ZusammenElement parameterElement = parameterToZusammenElement(parameter, role, Action.CREATE); + ZusammenElement parentElement = buildStructuralElement(getParentElementType(role), Action.IGNORE); + parentElement.addSubElement(parameterElement); + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + Element savedElement = zusammenAdaptor.saveElement(context, elementContext, parentElement, + "Create WorkflowVersion Parameter Element"); + + parameter.setId(savedElement.getSubElements().iterator().next().getElementId().getValue()); + return parameter; + } + + @Override + public void update(String id, String versionId, ParameterRole role, ParameterEntity parameter) { + + SessionContext context = createSessionContext(); + ElementContext elementContext = new ElementContext(id, versionId); + + ZusammenElement parameterElement = parameterToZusammenElement(parameter, role, Action.UPDATE); + + zusammenAdaptor.saveElement(context, elementContext, parameterElement, "Update WorkflowVersion Parameter"); + } + + private ZusammenElement parameterToZusammenElement(ParameterEntity parameter, ParameterRole role, Action action) { + + ZusammenElement parameterElement = + buildElement(parameter.getId() == null ? null : new Id(parameter.getId()), action); + Info info = new Info(); + info.setName(parameter.getName()); + info.addProperty(ElementPropertyName.elementType.name(), WorkflowElementType.valueOf(role.name())); + info.addProperty(ParameterPropertyName.TYPE.name(), parameter.getType()); + info.addProperty(ParameterPropertyName.mandatory.name(), parameter.isMandatory()); + parameterElement.setInfo(info); + + return parameterElement; + } + + private ParameterEntity mapElementInfoToParameter(ElementInfo elementInfo) { + ParameterEntity parameterEntity = new ParameterEntity(); + parameterEntity.setId(elementInfo.getId().getValue()); + parameterEntity.setName(elementInfo.getInfo().getName()); + parameterEntity + .setType(ParameterType.valueOf(elementInfo.getInfo().getProperty(ParameterPropertyName.TYPE.name()))); + parameterEntity.setMandatory(elementInfo.getInfo().getProperty(ParameterPropertyName.mandatory.name())); + return parameterEntity; + } + + private static String getParentElementType(ParameterRole role) { + switch (role) { + case INPUT: + return WorkflowElementType.INPUTS.name(); + case OUTPUT: + return WorkflowElementType.OUTPUTS.name(); + default: + throw new IllegalArgumentException("Wrong Element Type"); + } + } + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java new file mode 100644 index 00000000..287acb45 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ArtifactEntity.java @@ -0,0 +1,32 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +import java.io.InputStream; +import lombok.Data; + +@Data +public class ArtifactEntity { + + private String fileName; + private InputStream artifactData; + + public ArtifactEntity(String fileName, InputStream artifactData) { + this.fileName = fileName; + this.artifactData = artifactData; + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java new file mode 100644 index 00000000..7c957d85 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterEntity.java @@ -0,0 +1,34 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +import javax.validation.constraints.Pattern; +import lombok.Data; +import javax.validation.constraints.NotNull; + +@Data +public class ParameterEntity { + + private String id; + @NotNull(message = "Parameter name may not be null") + @Pattern(regexp = "[A-Za-z0-9_]*", message = "The field must contain only letters, digits and underscores") + private String name; + @NotNull + private ParameterType type; + @NotNull + private boolean mandatory; +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java new file mode 100644 index 00000000..fa17bf69 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterPropertyName.java @@ -0,0 +1,23 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +public enum ParameterPropertyName { + + TYPE, + mandatory +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java new file mode 100644 index 00000000..9f5aacfe --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterRole.java @@ -0,0 +1,24 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +public enum ParameterRole { + + INPUT, + OUTPUT + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java new file mode 100644 index 00000000..04d09c01 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/ParameterType.java @@ -0,0 +1,25 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +public enum ParameterType { + STRING, + INTEGER, + FLOAT, + BOOLEAN, + TIMESTAMP +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java new file mode 100644 index 00000000..ee7172b6 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/UniqueValueEntity.java @@ -0,0 +1,39 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +import static org.springframework.data.cassandra.core.cql.PrimaryKeyType.PARTITIONED; + +import lombok.Data; +import org.springframework.data.cassandra.core.mapping.PrimaryKeyColumn; +import org.springframework.data.cassandra.core.mapping.Table; + +@Table("unique_value") +@Data +public class UniqueValueEntity { + + @PrimaryKeyColumn(ordinal = 0, type = PARTITIONED) + private String type; + + @PrimaryKeyColumn(ordinal = 1, type = PARTITIONED) + private String value; + + public UniqueValueEntity(String type, String value) { + this.type = type; + this.value = value; + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java new file mode 100644 index 00000000..72e62778 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/Workflow.java @@ -0,0 +1,39 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + + +import java.util.Collection; +import java.util.Set; +import javax.validation.constraints.NotNull; +import javax.validation.constraints.Pattern; +import javax.validation.constraints.Size; +import lombok.Data; + + +@Data +public class Workflow { + + private String id; + @NotNull(message = "Workflow name may not be null") + @Size(min = 6, max = 30, message = "The field must be at least 6 characters, and less than 30 characters") + @Pattern(regexp = "[A-Za-z0-9_]*", message = "The field must contain only letters, digits and underscores") + private String name; + private String description; + private Set versionStates; + private Collection versions; +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java new file mode 100644 index 00000000..10de37e0 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowElementType.java @@ -0,0 +1,26 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +public enum WorkflowElementType { + + ARTIFACT, + INPUTS, + OUTPUTS, + INPUT, + OUTPUT +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java new file mode 100644 index 00000000..90fb3085 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowProperty.java @@ -0,0 +1,25 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +public final class WorkflowProperty { + + private WorkflowProperty() { + } + + public static final String CATEGORY = "category"; +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java new file mode 100644 index 00000000..1c828d43 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersion.java @@ -0,0 +1,46 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +import java.util.Collection; +import java.util.Collections; +import java.util.Date; +import lombok.Data; + + +@Data +public class WorkflowVersion { + + private String id; + private String name; + private String description; + private String baseId; + private WorkflowVersionState state; + private Collection inputs = Collections.emptyList(); + private Collection outputs = Collections.emptyList(); + private Date creationTime; + private Date modificationTime; + + + public WorkflowVersion(String id) { + this.id = id; + this.state = WorkflowVersionState.DRAFT; + } + + public WorkflowVersion() { + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java new file mode 100644 index 00000000..2be1d4da --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/persistence/types/WorkflowVersionState.java @@ -0,0 +1,36 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.persistence.types; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +public enum WorkflowVersionState { + + CERTIFIED, DRAFT(CERTIFIED); + + private final List nextStates; + + WorkflowVersionState(WorkflowVersionState... nextStates) { + this.nextStates = Collections.unmodifiableList(Arrays.asList(nextStates)); + } + + public List getNextStates() { + return nextStates; + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java new file mode 100644 index 00000000..5105114f --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/SwaggerConfig.java @@ -0,0 +1,24 @@ +package org.onap.sdc.workflow.server.config; + +import static springfox.documentation.builders.PathSelectors.regex; + +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import springfox.documentation.builders.RequestHandlerSelectors; +import springfox.documentation.spi.DocumentationType; +import springfox.documentation.spring.web.plugins.Docket; +import springfox.documentation.swagger2.annotations.EnableSwagger2; + +@Configuration +@EnableSwagger2 +public class SwaggerConfig { + + @Bean + public Docket api() { + return new Docket(DocumentationType.SWAGGER_2) + .select() + .apis(RequestHandlerSelectors.basePackage("org.onap.sdc.workflow.api")) + .paths(regex("/workflows.*")) + .build(); + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java new file mode 100644 index 00000000..092c3464 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/config/ZusammenConfig.java @@ -0,0 +1,32 @@ +package org.onap.sdc.workflow.server.config; + +import javax.annotation.PostConstruct; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.context.annotation.Configuration; + +@Configuration +public class ZusammenConfig { + + @Value("${zusammen-tenant:workflow}") + private String tenant; + @Value("${spring.data.cassandra.contact-points:localhost}") + private String cassandraAddress; + @Value("${spring.data.cassandra.username:}") + private String cassandraUser; + @Value("${spring.data.cassandra.password:}") + private String cassandraPassword; + @Value("${zusammen.cassandra.isAuthenticate:false}") + private String cassandraAuth; + + @PostConstruct + public void init(){ + System.setProperty("cassandra.nodes", cassandraAddress); + System.setProperty("cassandra.user", cassandraUser); + System.setProperty("cassandra.password", cassandraPassword); + System.setProperty("cassandra.authenticate", Boolean.toString(Boolean.valueOf(cassandraAuth))); + } + + public String getTenant() { + return tenant; + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java new file mode 100644 index 00000000..07d8eee7 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/server/filters/SessionContextFilter.java @@ -0,0 +1,64 @@ +package org.onap.sdc.workflow.server.filters; + +import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM; + +import java.io.IOException; +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.http.HttpServletRequest; +import org.onap.sdc.workflow.server.config.ZusammenConfig; +import org.openecomp.sdc.common.session.SessionContextProvider; +import org.openecomp.sdc.common.session.SessionContextProviderFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +@Component +public class SessionContextFilter implements Filter { + + private ZusammenConfig zusammenConfig; + + @Autowired + public SessionContextFilter(ZusammenConfig zusammenConfig) { + this.zusammenConfig = zusammenConfig; + } + + @Override + public void init(FilterConfig filterConfig) { + // not implemented + } + + @Override + public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) + throws IOException, ServletException { + SessionContextProvider contextProvider = SessionContextProviderFactory.getInstance().createInterface(); + + try { + if (servletRequest instanceof HttpServletRequest) { + contextProvider.create(getUser(servletRequest), getTenant()); + } + + filterChain.doFilter(servletRequest, servletResponse); + } finally { + contextProvider.close(); + } + } + + @Override + public void destroy() { + // not implemented + } + + private String getUser(ServletRequest servletRequest) { + return "GLOBAL_USER"; + // TODO: 7/11/2018 get user from header when collaboration will be supported + //((HttpServletRequest) servletRequest).getHeader(USER_ID_HEADER_PARAM); + } + + private String getTenant() { + return zusammenConfig.getTenant(); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java new file mode 100644 index 00000000..0a8b640a --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/UniqueValueService.java @@ -0,0 +1,123 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services; + +import java.util.Optional; +import org.apache.commons.lang.ArrayUtils; +import org.onap.sdc.workflow.persistence.UniqueValueRepository; +import org.onap.sdc.workflow.persistence.types.UniqueValueEntity; +import org.onap.sdc.workflow.services.exceptions.UniqueValueViolationException; +import org.openecomp.core.utilities.CommonMethods; // todo get rid of +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service("uniqueValueService") +public class UniqueValueService { + + private static final char FORMATTED_UNIQUE_VALUE_SEPARATOR = '_'; + + private final UniqueValueRepository uniqueValueRepository; + + @Autowired + public UniqueValueService(UniqueValueRepository uniqueValueRepository) { + this.uniqueValueRepository = uniqueValueRepository; + } + + /** + * Create unique value. + * + * @param type the type + * @param uniqueCombination the unique combination + */ + public void createUniqueValue(String type, String[] uniqueCombination) { + formatValue(uniqueCombination).ifPresent(formattedValue -> { + validateUniqueValue(type, formattedValue, uniqueCombination); + uniqueValueRepository.insert(new UniqueValueEntity(type, formattedValue)); + }); + } + + /** + * Delete unique value. + * + * @param type the type + * @param uniqueCombination the unique combination + */ + public void deleteUniqueValue(String type, String[] uniqueCombination) { + formatValue(uniqueCombination) + .ifPresent(formattedValue -> uniqueValueRepository.delete(new UniqueValueEntity(type, formattedValue))); + + } + + /** + * Update unique value. + * + * @param type the type + * @param oldValue the old value + * @param newValue the new value + * @param uniqueContext the unique context + */ + public void updateUniqueValue(String type, String oldValue, String newValue, String ... uniqueContext) { + if (newValue == null || !newValue.equalsIgnoreCase(oldValue)) { + createUniqueValue(type, CommonMethods.concat(uniqueContext, new String[] {newValue})); + deleteUniqueValue(type, CommonMethods.concat(uniqueContext, new String[] {oldValue})); + } + } + + /** + * Validate unique value. + * + * @param type the type + * @param uniqueCombination the unique combination + */ + public void validateUniqueValue(String type, String[] uniqueCombination) { + formatValue(uniqueCombination) + .ifPresent(formattedValue -> validateUniqueValue(type, formattedValue, uniqueCombination)); + } + + /** + * Checks if a unique value is taken. + * + * @return true if the unique value is occupied, false otherwise + */ + public boolean isUniqueValueOccupied(String type, String[] uniqueCombination) { + return formatValue(uniqueCombination).map(formattedValue -> isUniqueValueOccupied(type, formattedValue)) + .orElse(false); + } + + private void validateUniqueValue(String type, String formattedValue, String[] uniqueCombination) { + if (isUniqueValueOccupied(type, formattedValue)) { + throw new UniqueValueViolationException(type, getValueWithoutContext(uniqueCombination)); + } + } + + private boolean isUniqueValueOccupied(String type, String formattedValue) { + return uniqueValueRepository.findById(new UniqueValueEntity(type, formattedValue)).isPresent(); + } + + private Optional formatValue(String[] uniqueCombination) { + if (ArrayUtils.isEmpty(uniqueCombination) || getValueWithoutContext(uniqueCombination) == null) { + return Optional.empty(); + } + + uniqueCombination[uniqueCombination.length - 1] = getValueWithoutContext(uniqueCombination).toLowerCase(); + return Optional.of(CommonMethods.arrayToSeparatedString(uniqueCombination, FORMATTED_UNIQUE_VALUE_SEPARATOR)); + } + + private String getValueWithoutContext(String[] uniqueCombination) { + return uniqueCombination[uniqueCombination.length - 1]; + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java new file mode 100644 index 00000000..ca079d42 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowManager.java @@ -0,0 +1,34 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services; + +import java.util.Collection; +import java.util.Set; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.springframework.data.domain.Pageable; + +public interface WorkflowManager { + + Collection list(Set versionStatesFilter, Pageable pageable); + + Workflow get(Workflow workflow); + + Workflow create(Workflow workflow); + + void update(Workflow workflow); +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java new file mode 100644 index 00000000..1cb6cb1d --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowNameComparator.java @@ -0,0 +1,32 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services; + +import java.util.Comparator; + +import org.onap.sdc.workflow.persistence.types.Workflow; + +public class WorkflowNameComparator implements Comparator{ + + @Override + public int compare(Workflow workflow1, Workflow workflow2) { + String workflowName1 = workflow1.getName().toLowerCase(); + String workflowName2 = workflow2.getName().toLowerCase(); + //ascending order + return workflowName1.compareTo(workflowName2); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java new file mode 100644 index 00000000..8effb647 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/WorkflowVersionManager.java @@ -0,0 +1,46 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services; + +import java.util.Collection; +import java.util.Set; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.springframework.web.multipart.MultipartFile; + + +public interface WorkflowVersionManager { + + Collection list(String workflowId, Set stateFilter); + + WorkflowVersion create(String workflowId, String baseVersionId, WorkflowVersion version); + + void update(String workflowId, WorkflowVersion version); + + WorkflowVersion get(String workflowId, String versionId); + + WorkflowVersionState getState(String workflowId, String versionId); + + void updateState(String workflowId, String versionId, WorkflowVersionState state); + + ArtifactEntity getArtifact(String workflowId, String versionId); + + void deleteArtifact(String workflowId, String versionId); + + void uploadArtifact(String workflowId, String versionId, MultipartFile artifact); +} \ No newline at end of file diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java new file mode 100644 index 00000000..7fc3e81c --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/EntityNotFoundException.java @@ -0,0 +1,24 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + +public class EntityNotFoundException extends RuntimeException { + + public EntityNotFoundException(String message) { + super(message); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java new file mode 100644 index 00000000..c4584179 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidArtifactException.java @@ -0,0 +1,24 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + +public class InvalidArtifactException extends RuntimeException { + + public InvalidArtifactException(String message) { + super("Invalid artifact file can not be processed. Error: " + message); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java new file mode 100644 index 00000000..a4d4a5d6 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/InvalidPaginationParameterException.java @@ -0,0 +1,24 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + +public class InvalidPaginationParameterException extends RuntimeException { + + public InvalidPaginationParameterException(String parameterName, String parameterValue, String message) { + super(String.format("Requested %s: %s %s", parameterName, parameterValue, message)); + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java new file mode 100644 index 00000000..a3046a77 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/UniqueValueViolationException.java @@ -0,0 +1,27 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + + +public class UniqueValueViolationException extends RuntimeException { + + private static final String UNIQUE_VALUE_VIOLATION_MSG = "%s with the value '%s' already exists."; + + public UniqueValueViolationException(String uniqueType, String value) { + super(String.format(UNIQUE_VALUE_VIOLATION_MSG, uniqueType, value)); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java new file mode 100644 index 00000000..31c88923 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionCreationException.java @@ -0,0 +1,31 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + +public class VersionCreationException extends RuntimeException { + + private static final String MSG = "Error creating a new version for workflow with id %s"; + private static final String MSG_WITH_BASE_ID = MSG + " based on version %s: %s"; + + public VersionCreationException(String workflowId, String baseVersionId, String detailedMessage) { + super(String.format(MSG_WITH_BASE_ID, workflowId, baseVersionId, detailedMessage)); + } + + public VersionCreationException(String workflowId) { + super(String.format(MSG, workflowId)); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java new file mode 100644 index 00000000..752d6bce --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionModificationException.java @@ -0,0 +1,26 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + +public class VersionModificationException extends RuntimeException { + + public VersionModificationException(String workflowId, String versionId) { + super(String.format( + "Error while trying to modify version %s of workflow %s: Version is CERTIFIED and can not be edited", + versionId, workflowId)); + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java new file mode 100644 index 00000000..87027a58 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/exceptions/VersionStateModificationException.java @@ -0,0 +1,28 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.exceptions; + +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; + +public class VersionStateModificationException extends RuntimeException { + + public VersionStateModificationException(String workflowId, String versionId, WorkflowVersionState sourceState, + WorkflowVersionState targetState) { + super(String.format("Workflow %s, version %s: state can not be changed from %s to %s", workflowId, versionId, + sourceState.name(), targetState.name())); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java new file mode 100644 index 00000000..80b969cf --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/CollaborationConfiguration.java @@ -0,0 +1,38 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.impl; + +import org.openecomp.sdc.versioning.ItemManager; +import org.openecomp.sdc.versioning.ItemManagerFactory; +import org.openecomp.sdc.versioning.VersioningManager; +import org.openecomp.sdc.versioning.VersioningManagerFactory; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; + +@Configuration +public class CollaborationConfiguration { + + @Bean + public ItemManager itemManager() { + return ItemManagerFactory.getInstance().createInterface(); + } + + @Bean + public VersioningManager versioningManager() { + return VersioningManagerFactory.getInstance().createInterface(); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java new file mode 100644 index 00000000..52dd8f17 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImpl.java @@ -0,0 +1,159 @@ +/* + * Copyright © 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. + */ +package org.onap.sdc.workflow.services.impl; + +import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Set; +import java.util.function.Predicate; +import java.util.stream.Collectors; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.onap.sdc.workflow.services.UniqueValueService; +import org.onap.sdc.workflow.services.WorkflowManager; +import org.onap.sdc.workflow.services.WorkflowNameComparator; +import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException; +import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper; +import org.onap.sdc.workflow.services.impl.mappers.WorkflowMapper; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.versioning.ItemManager; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; +import org.openecomp.sdc.versioning.types.Item; +import org.openecomp.sdc.versioning.types.ItemStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.data.domain.Pageable; +import org.springframework.data.domain.Sort; +import org.springframework.stereotype.Service; + +@Service("workflowManager") +public class WorkflowManagerImpl implements WorkflowManager { + + public static final String WORKFLOW_TYPE = "WORKFLOW"; + private static final String WORKFLOW_NOT_FOUND_ERROR_MSG = "Workflow with id '%s' does not exist"; + private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME"; + private static final Predicate WORKFLOW_ITEM_FILTER = item -> WORKFLOW_TYPE.equals(item.getType()); + + private static final Logger LOGGER = LoggerFactory.getLogger(WorkflowManagerImpl.class); + private final ItemManager itemManager; + private final UniqueValueService uniqueValueService; + private final WorkflowMapper workflowMapper; + private final VersionStateMapper versionStateMapper; + + @Autowired + public WorkflowManagerImpl(ItemManager itemManager, + @Qualifier("uniqueValueService") UniqueValueService uniqueValueService, WorkflowMapper workflowMapper, + VersionStateMapper versionStateMapper) { + this.itemManager = itemManager; + this.uniqueValueService = uniqueValueService; + this.workflowMapper = workflowMapper; + this.versionStateMapper = versionStateMapper; + } + + @Override + public Collection list(Set versionStatesFilter, Pageable pageRequest) { + Set versionStatusesFilter = + versionStatesFilter == null ? null : + versionStatesFilter.stream().map(versionStateMapper::workflowVersionStateToVersionStatus) + .collect(Collectors.toSet()); + + + List workflows = itemManager.list(getFilter(versionStatusesFilter)).stream() + .map(workflowMapper::itemToWorkflow) + .sorted(pageRequest.getSort().getOrderFor(SORT_FIELD_NAME).getDirection() + == Sort.Direction.ASC ? getWorkflowsComparator() : + Collections.reverseOrder(getWorkflowsComparator())) + .collect(Collectors.toList()); + return applyLimitAndOffset(workflows, pageRequest); + } + + @Override + public Workflow get(Workflow workflow) { + Item retrievedItem = itemManager.get(workflow.getId()); + if (retrievedItem == null) { + LOGGER.error(String.format("Workflow with id %s was not found",workflow.getId())); + throw new EntityNotFoundException(String.format(WORKFLOW_NOT_FOUND_ERROR_MSG, workflow.getId())); + } + return this.workflowMapper.itemToWorkflow(retrievedItem); + } + + @Override + public Workflow create(Workflow workflow) { + Item item = workflowMapper.workflowToItem(workflow); + item.setStatus(ItemStatus.ACTIVE); + + uniqueValueService.validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflow.getName()}); + Item createdItem = itemManager.create(item); + uniqueValueService.createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflow.getName()}); + + return workflowMapper.itemToWorkflow(createdItem); + } + + @Override + public void update(Workflow workflow) { + Item retrievedItem = itemManager.get(workflow.getId()); + if (retrievedItem == null) { + LOGGER.error(String.format("Workflow with id %s was not found",workflow.getId())); + throw new EntityNotFoundException(String.format(WORKFLOW_NOT_FOUND_ERROR_MSG, workflow.getId())); + } + + uniqueValueService.updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, retrievedItem.getName(), workflow.getName()); + + Item item = workflowMapper.workflowToItem(workflow); + item.setId(workflow.getId()); + item.setStatus(retrievedItem.getStatus()); + item.setVersionStatusCounters(retrievedItem.getVersionStatusCounters()); + itemManager.update(item); + } + + private List applyLimitAndOffset(List workflowList, Pageable pageRequest) { + int limit = pageRequest.getPageSize(); + int offset = pageRequest.getPageNumber(); + int totalNumOfWorkflows = workflowList.size(); + List selectedWorkflows; + try { + if (limit > totalNumOfWorkflows) { + limit = totalNumOfWorkflows; + } + int startIndex = offset * limit; + int endIndex = startIndex + limit; + if (endIndex > totalNumOfWorkflows) { + endIndex = totalNumOfWorkflows; + } + selectedWorkflows = workflowList.subList(startIndex, endIndex); + } catch (IndexOutOfBoundsException | IllegalArgumentException ex) { + selectedWorkflows = new ArrayList<>(); + } + return selectedWorkflows; + } + + private Comparator getWorkflowsComparator() { + //More comparators can be added if required based on sort field name + return new WorkflowNameComparator(); + } + + private static Predicate getFilter(Set versionStatuses) { + return WORKFLOW_ITEM_FILTER.and(item -> versionStatuses == null + || item.getVersionStatusCounters().keySet().stream() + .anyMatch(versionStatuses::contains)); + } +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java new file mode 100644 index 00000000..484c598a --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImpl.java @@ -0,0 +1,277 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.impl; + +import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.CERTIFIED; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.function.Function; +import java.util.stream.Collectors; +import org.onap.sdc.workflow.persistence.ArtifactRepository; +import org.onap.sdc.workflow.persistence.ParameterRepository; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; +import org.onap.sdc.workflow.persistence.types.ParameterEntity; +import org.onap.sdc.workflow.persistence.types.ParameterRole; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.onap.sdc.workflow.services.WorkflowVersionManager; +import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException; +import org.onap.sdc.workflow.services.exceptions.InvalidArtifactException; +import org.onap.sdc.workflow.services.exceptions.VersionCreationException; +import org.onap.sdc.workflow.services.exceptions.VersionModificationException; +import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException; +import org.onap.sdc.workflow.services.impl.mappers.VersionMapper; +import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper; +import org.openecomp.sdc.logging.api.Logger; +import org.openecomp.sdc.logging.api.LoggerFactory; +import org.openecomp.sdc.versioning.VersioningManager; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; +import org.openecomp.sdc.versioning.types.VersionCreationMethod; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.util.StringUtils; +import org.springframework.web.multipart.MultipartFile; + +@Service("workflowVersionManager") +public class WorkflowVersionManagerImpl implements WorkflowVersionManager { + + private static final String VERSION_NOT_EXIST_MSG = "version with id '%s' does not exist for workflow with id '%s'"; + private final VersioningManager versioningManager; + private final ArtifactRepository artifactRepository; + private final ParameterRepository parameterRepository; + private final VersionMapper versionMapper; + private final VersionStateMapper versionStateMapper; + private static final Logger LOGGER = LoggerFactory.getLogger(WorkflowVersionManagerImpl.class); + + @Autowired + public WorkflowVersionManagerImpl(VersioningManager versioningManager, ArtifactRepository artifactRepository, + VersionMapper versionMapper, VersionStateMapper versionStateMapper, + ParameterRepository parameterRepository) { + this.versioningManager = versioningManager; + this.artifactRepository = artifactRepository; + this.parameterRepository = parameterRepository; + this.versionMapper = versionMapper; + this.versionStateMapper = versionStateMapper; + } + + @Override + public Collection list(String workflowId, Set stateFilter) { + Set versionStatusFilter = + stateFilter == null ? null : + stateFilter.stream().map(versionStateMapper::workflowVersionStateToVersionStatus) + .collect(Collectors.toSet()); + + return versioningManager.list(workflowId).stream() + .filter(version -> versionStatusFilter == null || versionStatusFilter.contains( + version.getStatus())) + .map(versionMapper::versionToWorkflowVersion) + .peek(workflowVersion -> loadAndAddParameters(workflowId, workflowVersion)) + .collect(Collectors.toList()); + } + + @Override + public WorkflowVersion get(String workflowId, String versionId) { + WorkflowVersion workflowVersion = versionMapper.versionToWorkflowVersion(getVersion(workflowId, versionId)); + loadAndAddParameters(workflowId, workflowVersion); + return workflowVersion; + } + + @Override + public WorkflowVersion create(String workflowId, String baseVersionId, WorkflowVersion workflowVersion) { + List versions = versioningManager.list(workflowId); + + if (baseVersionId != null) { + if (!workflowVersion.getInputs().isEmpty() || !workflowVersion.getOutputs().isEmpty()) { + throw new VersionCreationException(workflowId, baseVersionId, "Inputs/Outputs should not be supplied"); + } + validateVersionExistAndCertified(workflowId, versions, baseVersionId); + } else if (!versions.isEmpty()) { + throw new VersionCreationException(workflowId); + } + + Version version = new Version(); + version.setDescription(workflowVersion.getDescription()); + version.setBaseId(baseVersionId); + Version createdVersion = versioningManager.create(workflowId, version, VersionCreationMethod.major); + + if (versions.isEmpty()) { // only for first version + artifactRepository.createStructure(workflowId, createdVersion.getId()); + parameterRepository.createStructure(workflowId, createdVersion.getId()); + updateParameters(workflowId, createdVersion.getId(), workflowVersion.getInputs(), workflowVersion.getOutputs()); + versioningManager.publish(workflowId, createdVersion, "Add initial data"); + } + + return get(workflowId, createdVersion.getId()); + } + + @Override + public void update(String workflowId, WorkflowVersion workflowVersion) { + Version retrievedVersion = getVersion(workflowId, workflowVersion.getId()); + if (CERTIFIED.equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) { + throw new VersionModificationException(workflowId, workflowVersion.getId()); + } + + Version version = versionMapper.workflowVersionToVersion(workflowVersion); + version.setName(retrievedVersion.getName()); + version.setStatus(retrievedVersion.getStatus()); + + updateParameters(workflowId, version.getId(), workflowVersion.getInputs(), workflowVersion.getOutputs()); + + versioningManager.updateVersion(workflowId, version); + versioningManager.publish(workflowId, version, "Update version"); + } + + @Override + public WorkflowVersionState getState(String workflowId, String versionId) { + return versionStateMapper.versionStatusToWorkflowVersionState(getVersion(workflowId, versionId).getStatus()); + } + + @Override + public void updateState(String workflowId, String versionId, WorkflowVersionState state) { + WorkflowVersionState retrievedState = + versionStateMapper.versionStatusToWorkflowVersionState(getVersion(workflowId, versionId).getStatus()); + + if (state == CERTIFIED) { + try { + versioningManager.submit(workflowId, new Version(versionId), + String.format("Update version state to %s", state.name())); + } catch (Exception e) { + throw new VersionStateModificationException(workflowId, versionId, retrievedState, state); + } + } else { + throw new VersionStateModificationException(workflowId, versionId, retrievedState, state); + } + } + + @Override + public void uploadArtifact(String workflowId, String versionId, MultipartFile artifact) { + Version retrievedVersion = getVersion(workflowId, versionId); + if (CERTIFIED.equals(versionStateMapper.versionStatusToWorkflowVersionState(retrievedVersion.getStatus()))) { + throw new VersionModificationException(workflowId, versionId); + } + + try (InputStream artifactData = artifact.getInputStream()) { + ArtifactEntity artifactEntity = + new ArtifactEntity(StringUtils.cleanPath(artifact.getOriginalFilename()), artifactData); + artifactRepository.update(workflowId, versionId, artifactEntity); + versioningManager.publish(workflowId, new Version(versionId), "Update Artifact"); + + } catch (IOException e) { + LOGGER.error(String.format("Upload Artifact failed for workflow id %s and version id %s", + workflowId, versionId),e); + throw new InvalidArtifactException(e.getMessage()); + } + } + + @Override + public ArtifactEntity getArtifact(String workflowId, String versionId) { + getVersion(workflowId, versionId); + Optional artifactOptional = artifactRepository.get(workflowId, versionId); + if (!artifactOptional.isPresent()) { + LOGGER.error(String.format("Workflow Version Artifact was not found for workflow id %s and version id %s", + workflowId, versionId)); + throw new EntityNotFoundException( + String.format("Artifact for workflow id %S version id %S was not found", workflowId, versionId)); + } + return artifactOptional.get(); + } + + @Override + public void deleteArtifact(String workflowId, String versionId) { + WorkflowVersion retrievedVersion = get(workflowId, versionId); + if (CERTIFIED.equals(retrievedVersion.getState())) { + LOGGER.error(String.format( + "Workflow Version is certified and can not be edited.Workflow id %s and version id %s", workflowId, + versionId)); + throw new VersionModificationException(workflowId, versionId); + } + + artifactRepository.delete(workflowId, versionId); + versioningManager.publish(workflowId, new Version(versionId), "Delete Artifact"); + } + + private void validateVersionExistAndCertified(String workflowId, List versions, String versionId) { + Version baseVersion = findVersion(versions, versionId).orElseThrow( + () -> new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId))); + + if (CERTIFIED != versionStateMapper.versionStatusToWorkflowVersionState(baseVersion.getStatus())) { + throw new VersionCreationException(workflowId, versionId, "base version must be CERTIFIED"); + } + } + + private Version getVersion(String workflowId, String versionId) { + try { + Version version = versioningManager.get(workflowId, new Version(versionId)); + if (version == null) { + throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId)); + } + return version; + } catch (Exception e) { + LOGGER.error(String.format( + "Workflow Version was not found.Workflow id %s and version id %s", workflowId, + versionId),e); + throw new EntityNotFoundException(String.format(VERSION_NOT_EXIST_MSG, versionId, workflowId)); + } + } + + private void updateParameters(String workflowId, String versionId, Collection inputs, + Collection outputs) { + updateVersionParameters(workflowId, versionId, ParameterRole.INPUT, inputs); + updateVersionParameters(workflowId, versionId, ParameterRole.OUTPUT, outputs); + } + + private void updateVersionParameters(String workflowId, String versionId, ParameterRole role, + Collection parameters) { + + Collection retrievedParams = parameterRepository.list(workflowId, versionId, role); + Map retrievedParamsByName = + retrievedParams.stream().collect(Collectors.toMap(ParameterEntity::getName, Function.identity())); + + Set namesOfParamsToKeep = new HashSet<>(); + for (ParameterEntity parameter : parameters) { + + ParameterEntity retrievedParam = retrievedParamsByName.get(parameter.getName()); + if (retrievedParam == null) { + parameterRepository.create(workflowId, versionId, role, parameter); + } else { + parameterRepository.update(workflowId, versionId, role, parameter); + namesOfParamsToKeep.add(parameter.getName()); + } + } + + retrievedParams.stream().filter(retrievedParam -> !namesOfParamsToKeep.contains(retrievedParam.getName())) + .forEach(retrievedParam -> parameterRepository + .delete(workflowId, versionId, retrievedParam.getId())); + } + + private void loadAndAddParameters(String workflowId, WorkflowVersion workflowVersion) { + workflowVersion.setInputs(parameterRepository.list(workflowId, workflowVersion.getId(), ParameterRole.INPUT)); + workflowVersion.setOutputs(parameterRepository.list(workflowId, workflowVersion.getId(), ParameterRole.OUTPUT)); + } + + private static Optional findVersion(List versions, String versionId) { + return versions.stream().filter(version -> versionId.equals(version.getId())).findFirst(); + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java new file mode 100644 index 00000000..a3a1cdcc --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapper.java @@ -0,0 +1,35 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.impl.mappers; + +import org.mapstruct.InheritInverseConfiguration; +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.openecomp.sdc.versioning.dao.types.Version; + +@Mapper(componentModel = "spring", uses = VersionStateMapper.class) +public interface VersionMapper { + + + @Mapping(source = "status", target = "state") + WorkflowVersion versionToWorkflowVersion(Version version); + + @InheritInverseConfiguration + Version workflowVersionToVersion(WorkflowVersion workflowVersion); + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java new file mode 100644 index 00000000..45012b57 --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapper.java @@ -0,0 +1,47 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.impl.mappers; + +import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; +import org.mapstruct.InheritInverseConfiguration; +import org.mapstruct.Mapper; +import org.mapstruct.ValueMapping; +import org.mapstruct.ValueMappings; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; + +@Mapper(componentModel = "spring") +public interface VersionStateMapper { + + @ValueMappings({@ValueMapping(source = "Certified", target = "CERTIFIED"), + @ValueMapping(source = "Draft", target = "DRAFT"), + @ValueMapping(source = "", target = "DRAFT")}) + WorkflowVersionState versionStatusToWorkflowVersionState(VersionStatus status); + + @InheritInverseConfiguration + VersionStatus workflowVersionStateToVersionStatus(WorkflowVersionState status); + + default Set versionStatusCountersToWorkflowVersionStates( + Map versionStatusCounters) { + return versionStatusCounters.keySet().stream().map(this::versionStatusToWorkflowVersionState) + .collect(Collectors.toSet()); + } + + +} diff --git a/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java new file mode 100644 index 00000000..5cfcd7ed --- /dev/null +++ b/workflow-designer-be/src/main/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapper.java @@ -0,0 +1,38 @@ +/* + * Copyright © 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. + */ + +package org.onap.sdc.workflow.services.impl.mappers; + +import org.mapstruct.InheritInverseConfiguration; +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; +import org.mapstruct.Mappings; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.onap.sdc.workflow.services.impl.WorkflowManagerImpl; +import org.openecomp.sdc.versioning.types.Item; + +@Mapper(componentModel = "spring", imports = WorkflowManagerImpl.class, uses = VersionStateMapper.class) +public interface WorkflowMapper { + + @Mapping(source = "versionStatusCounters", target = "versionStates") + Workflow itemToWorkflow(Item item); + + @InheritInverseConfiguration + @Mappings({@Mapping(expression = "java(WorkflowManagerImpl.WORKFLOW_TYPE)", target = "type"), + @Mapping(target = "versionStatusCounters", ignore = true)}) + Item workflowToItem(Workflow workflow); + +} diff --git a/workflow-designer-be/src/main/resources/application.properties b/workflow-designer-be/src/main/resources/application.properties new file mode 100644 index 00000000..ab4930b5 --- /dev/null +++ b/workflow-designer-be/src/main/resources/application.properties @@ -0,0 +1,10 @@ +server.servlet.context-path=/wf +server.port=${SERVER_PORT:8080} + +#CASSANDRA +spring.data.cassandra.contact-points=${CS_HOSTS} +spring.data.cassandra.keyspace-name=workflow +spring.data.cassandra.port=${CS_PORT:9042} +spring.data.cassandra.username=${CS_USER:} +spring.data.cassandra.password=${CS_PASSWORD:} +zusammen.cassandra.isAuthenticate=${CS_AUTHENTICATE:true} \ No newline at end of file diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java new file mode 100644 index 00000000..7a7e715e --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/RestPath.java @@ -0,0 +1,66 @@ +package org.onap.sdc.workflow; + +import static org.onap.sdc.workflow.api.RestConstants.SIZE_PARAM; +import static org.onap.sdc.workflow.api.RestConstants.PAGE_PARAM; +import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM; + +public class RestPath { + + private RestPath() { + //Hiding implicit constructor + } + + private static final String WORKFLOWS_URL = "/workflows"; + public static final String WORKFLOWS_WITH_VERSION_STATE_FILTER_URL = WORKFLOWS_URL + "?versionState=%s"; + private static final String WORKFLOW_URL_FORMATTER = WORKFLOWS_URL + "/%s"; + private static final String VERSIONS_URL_FORMATTER = WORKFLOWS_URL + "/%s/versions"; + private static final String VERSION_URL_FORMATTER = WORKFLOWS_URL + "/%s/versions/%s"; + private static final String SORT_QUERY_STRING_FORMATTER = SORT_PARAM + "=%s"; + private static final String SIZE_QUERY_STRING_FORMATTER = SIZE_PARAM + "=%s"; + private static final String OFFSET_QUERY_STRING_FORMATTER = PAGE_PARAM + "=%s"; + private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_ALL = + WORKFLOWS_URL + "?" + SORT_QUERY_STRING_FORMATTER+ "&" + SIZE_QUERY_STRING_FORMATTER + "&" + + OFFSET_QUERY_STRING_FORMATTER; + private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT = + WORKFLOWS_URL + "?" + SIZE_QUERY_STRING_FORMATTER + "&" + OFFSET_QUERY_STRING_FORMATTER; + private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_SIZE = + WORKFLOWS_URL + "?" + OFFSET_QUERY_STRING_FORMATTER; + private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_OFFSET = + WORKFLOWS_URL + "?" + SIZE_QUERY_STRING_FORMATTER; + + public static String getWorkflowsPathAllQueryParams(String sort, String size, String offset){ + return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_ALL, sort, size, offset); + } + + public static String getWorkflowsPathNoSort(String size, String offset){ + return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT, size, offset); + } + + public static String getWorkflowsPathNoSortAndSize(String offset){ + return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_SIZE, offset); + } + + public static String getWorkflowsPathNoSortAndOffset(String size){ + return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_OFFSET, size); + } + + public static String getWorkflowsPath() { + return WORKFLOWS_URL; + } + + public static String getWorkflowsWithVersionStateFilterPath(String versionState) { + return String.format(WORKFLOWS_WITH_VERSION_STATE_FILTER_URL, versionState); + } + + public static String getWorkflowPath(String workflowId) { + return String.format(WORKFLOW_URL_FORMATTER, workflowId); + } + + public static String getWorkflowVersions(String workflowId) { + return String.format(VERSIONS_URL_FORMATTER, workflowId); + } + + public static String getWorkflowVersion(String workflowId, String versionId) { + return String.format(VERSION_URL_FORMATTER, workflowId, versionId); + } +} diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java new file mode 100644 index 00000000..e2a566aa --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/TestUtil.java @@ -0,0 +1,35 @@ +package org.onap.sdc.workflow; + +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.openecomp.sdc.versioning.types.Item; + +public class TestUtil { + + private static final String WORKFLOW_TYPE = "WORKFLOW"; + + public static Workflow createWorkflow(int workflowNum, boolean createId) { + Workflow workflow = new Workflow(); + if (createId) { + workflow.setId(String.valueOf(workflowNum)); + } + workflow.setName("Workflow_" + workflowNum); + workflow.setDescription("Description_" + workflowNum); + + return workflow; + } + + public static Item createItem(int itemNum, boolean setType, boolean setId) { + Item item = new Item(); + if (setId) { + item.setId(String.valueOf(itemNum)); + } + item.setName("Workflow_" + itemNum); + item.setDescription("Description_" + itemNum); + if (setType) { + item.setType(WORKFLOW_TYPE); + } + return item; + } + + +} diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java new file mode 100644 index 00000000..5e7df483 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java @@ -0,0 +1,287 @@ +package org.onap.sdc.workflow.api; + +import static org.hamcrest.Matchers.is; +import static org.hamcrest.collection.IsCollectionWithSize.hasSize; +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.verify; +import static org.onap.sdc.workflow.TestUtil.createWorkflow; +import static org.onap.sdc.workflow.api.RestConstants.PAGE_DEFAULT; +import static org.onap.sdc.workflow.api.RestConstants.SIZE_DEFAULT; +import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME; +import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM; +import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM; +import static org.springframework.http.MediaType.APPLICATION_JSON; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.item.Item; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.collect.ImmutableSet; +import com.google.gson.Gson; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Set; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.sdc.workflow.RestPath; +import org.onap.sdc.workflow.api.exceptionshandlers.CustomizedResponseEntityExceptionHandler; +import org.onap.sdc.workflow.api.types.CollectionWrapper; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.onap.sdc.workflow.services.WorkflowManager; +import org.springframework.data.web.PageableHandlerMethodArgumentResolver; +import org.springframework.mock.web.MockHttpServletResponse; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +@RunWith(MockitoJUnitRunner.class) +public class WorkflowControllerTest { + + private static final String MISSING_REQUEST_HEADER_ERRROR_FORMAT = + "Missing request header '%s' for method parameter of type String"; + private static final String USER_ID = "userId"; + private static final Gson GSON = new Gson(); + private static final String USER_ID_HEADER = "USER_ID"; + private static final String INVALID_PAGINATION_PARAMETER_FORMAT = "Requested %s: %s %s"; + private static final String PAGINATION_PARAMETER_INVALID_SORT_FIELD_SUFFIX = + "is not supported. Supported values are: "; + private static final String DEFAULT_SORT_VALUE = "name,asc"; + + private MockMvc mockMvc; + + + @InjectMocks + private WorkflowController workflowController; + + @Mock + private WorkflowManager workflowManagerMock; + + @Before + public void setUp() { + mockMvc = MockMvcBuilders.standaloneSetup(workflowController) + .setCustomArgumentResolvers(new PageableHandlerMethodArgumentResolver()) + .setControllerAdvice(new CustomizedResponseEntityExceptionHandler()).build(); + } + + @Test + public void shouldReturnErrorWhenMissingUserIdInGetReqHeader() throws Exception { + Workflow workflowMock = createWorkflow(1, true); + MockHttpServletResponse response = + mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isBadRequest()).andExpect(status().is(400)).andReturn() + .getResponse(); + assertEquals(String.format(MISSING_REQUEST_HEADER_ERRROR_FORMAT, USER_ID_HEADER), + response.getContentAsString()); + } + + @Test + public void shouldReturnWorkflowDataWhenRequestPathIsOk() throws Exception { + Workflow workflowMock = createWorkflow(1, true); + doReturn(workflowMock).when(workflowManagerMock).get(any(Workflow.class)); + mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).header(USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.id", is(workflowMock.getId()))) + .andExpect(jsonPath("$.name", is(workflowMock.getName()))); + } + + @Test + public void shouldReturnErrorWhenMissingUserIdInListReqHeader() throws Exception { + MockHttpServletResponse response = + mockMvc.perform(get(RestPath.getWorkflowsPath()).contentType(APPLICATION_JSON)).andDo(print()) + .andExpect(status().isBadRequest()).andExpect(status().is(400)).andReturn().getResponse(); + assertEquals(String.format(MISSING_REQUEST_HEADER_ERRROR_FORMAT, USER_ID_HEADER_PARAM), + response.getContentAsString()); + } + + @Test + public void shouldReturn5WorkflowWhen5WorkflowsExists() throws Exception { + int numOfWorkflows = 5; + List workflowMocks = createWorkflows(numOfWorkflows); + doReturn(workflowMocks).when(workflowManagerMock).list(any(), any()); + mockMvc.perform( + get(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(numOfWorkflows))); + } + + @Test + public void listWithValidVersionStateFilter() throws Exception { + int numOfWorkflows = 3; + List workflows = createWorkflows(numOfWorkflows); + doReturn(workflows).when(workflowManagerMock) + .list(eq(Collections.singleton(WorkflowVersionState.CERTIFIED)), any()); + mockMvc.perform( + get(RestPath.getWorkflowsWithVersionStateFilterPath("CERTIFIED")).header(USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.total", is(numOfWorkflows))) + .andExpect(jsonPath("$.results", hasSize(numOfWorkflows))); + } + + @Test + public void listWithInvalidVersionStateFilter() throws Exception { + mockMvc.perform( + get(RestPath.getWorkflowsWithVersionStateFilterPath("hasdhf")).header(USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.total", is(0))); + } + + @Test + public void shouldReturnSortedSizeOffsetAppliedWorkflows() throws Exception { + List workflowMocks = createSize2AndOffset1For5WorkflowList(); + doReturn(workflowMocks).when(workflowManagerMock).list(any(), any()); + mockMvc.perform(get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "1")) + .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2))); + } + + @Test + public void shouldReturnResultsWithDefaultWhenSizeIsNegative() throws Exception { + List workflowMocks = createSize2AndOffset1For5WorkflowList(); + doReturn(workflowMocks).when(workflowManagerMock).list(any(), any()); + MockHttpServletResponse response = mockMvc.perform( + get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "-2", "1")) + .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200)) + .andReturn().getResponse(); + CollectionWrapper workflowListResponse = + new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class); + assertEquals(SIZE_DEFAULT, workflowListResponse.getSize()); + assertEquals(1, workflowListResponse.getPage()); + assertEquals(2, workflowListResponse.getTotal()); + } + + @Test + public void shouldFallbackOnDefaultOffsetWhenOffsetIsNegative() throws Exception { + MockHttpServletResponse response = mockMvc.perform( + get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "-1")) + .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200)) + .andReturn().getResponse(); + CollectionWrapper workflowListResponse = + new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class); + assertEquals(2, workflowListResponse.getSize()); + assertEquals(PAGE_DEFAULT, workflowListResponse.getPage()); + assertEquals(0, workflowListResponse.getTotal()); + } + + @Test + public void shouldFallbackOnDefaultSizeWhenSizeIsNotAnInteger() throws Exception { + MockHttpServletResponse response = mockMvc.perform( + get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "abc", "0")) + .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200)) + .andReturn().getResponse(); + CollectionWrapper workflowListResponse = + new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class); + assertEquals(SIZE_DEFAULT, workflowListResponse.getSize()); + assertEquals(0, workflowListResponse.getPage()); + assertEquals(0, workflowListResponse.getTotal()); + } + + @Test + public void shouldFallbackOnDefaultOffsetWhenOffsetIsNotAnInteger() throws Exception { + MockHttpServletResponse response = mockMvc.perform( + get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "abc")) + .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200)) + .andReturn().getResponse(); + CollectionWrapper workflowListResponse = + new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class); + assertEquals(2, workflowListResponse.getSize()); + assertEquals(PAGE_DEFAULT, workflowListResponse.getPage()); + assertEquals(0, workflowListResponse.getTotal()); + } + + @Test + public void shouldThrowExceptionWhenSortFieldIsInvalid() throws Exception { + MockHttpServletResponse response = mockMvc.perform( + get(RestPath.getWorkflowsPathAllQueryParams("invalidSortField,asc", "2", "1")) + .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)) + .andDo(print()).andExpect(status().isBadRequest()) + .andExpect(status().is(400)).andReturn().getResponse(); + assertEquals(String.format(INVALID_PAGINATION_PARAMETER_FORMAT, SORT_PARAM, "invalidSortField", + PAGINATION_PARAMETER_INVALID_SORT_FIELD_SUFFIX + getSupportedSortFields()), + response.getContentAsString()); + } + + @Test + public void shouldReturnAscSortedSizeOffsetAppliedWorkflowsWhenSortIsNotSpecified() throws Exception { + List workflowMocks = createSize2AndOffset1For5WorkflowList(); + doReturn(workflowMocks).when(workflowManagerMock).list(any(), any()); + mockMvc.perform( + get(RestPath.getWorkflowsPathNoSort("2", "1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)).andDo(print()) + .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2))); + } + + @Test + public void shouldReturnDefaultSizeOffsetAppliedWorkflowsWhenSizeIsNotSpecified() throws Exception { + List workflowMocks = createSize2AndOffset1For5WorkflowList(); + doReturn(workflowMocks).when(workflowManagerMock).list(any(), any()); + mockMvc.perform( + get(RestPath.getWorkflowsPathNoSortAndSize("1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)).andDo(print()) + .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2))); + } + + @Test + public void shouldReturnDefaultOffsetAppliedWorkflowsWhenOffsetIsNotSpecified() throws Exception { + List workflowMocks = createSize1WorkflowList(); + doReturn(workflowMocks).when(workflowManagerMock).list(any(), any()); + mockMvc.perform( + get(RestPath.getWorkflowsPathNoSortAndOffset("1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)).andDo(print()) + .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(1))); + } + + @Test + public void shouldCreateWorkflowWhenCallingPostRESTRequest() throws Exception { + Item item = new Item(); + item.setId(new Id("abc")); + Workflow reqWorkflow = createWorkflow(1, false); + mockMvc.perform( + post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON) + .content(GSON.toJson(reqWorkflow))).andDo(print()) + .andExpect(status().isCreated()); + verify(workflowManagerMock).create(reqWorkflow); + } + + private List createWorkflows(int numOfWorkflows) { + List workflowList = new ArrayList<>(numOfWorkflows); + for (int i = 0; i < numOfWorkflows; i++) { + workflowList.add(createWorkflow(i, true)); + } + + return workflowList; + } + + private List createSize2AndOffset1For5WorkflowList() { + List workflowList = new ArrayList<>(); + workflowList.add(createWorkflow(2, true)); + workflowList.add(createWorkflow(3, true)); + return workflowList; + } + + private List createSize1WorkflowList() { + List workflowList = new ArrayList<>(); + workflowList.add(createWorkflow(0, true)); + return workflowList; + } + + + private Set getSupportedSortFields() { + return ImmutableSet.of(SORT_FIELD_NAME); + } + +} \ No newline at end of file diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java new file mode 100644 index 00000000..ee9a56c8 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowVersionControllerTest.java @@ -0,0 +1,117 @@ +package org.onap.sdc.workflow.api; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.collection.IsCollectionWithSize.hasSize; +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.springframework.http.MediaType.APPLICATION_JSON; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put; +import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +import com.google.gson.Gson; +import java.util.Arrays; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.sdc.workflow.RestPath; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.onap.sdc.workflow.services.WorkflowVersionManager; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.springframework.http.HttpStatus; +import org.springframework.mock.web.MockHttpServletResponse; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +@RunWith(MockitoJUnitRunner.class) +public class WorkflowVersionControllerTest { + + private static final String USER_ID = "cs0008"; + private static final String ITEM1_ID = "item_id_1"; + private static final String VERSION1_ID = "version_id_1"; + private static final String VERSION2_ID = "version_id_2"; + private List versionList; + + private static final Gson GSON = new Gson(); + + private MockMvc mockMvc; + + @Mock + private WorkflowVersionManager workflowVersionManagerMock; + + @InjectMocks + private WorkflowVersionController workflowVersionController; + + @Before + public void setUp() { + versionList = Arrays.asList( new Version(VERSION1_ID),new Version(VERSION2_ID)); + mockMvc = MockMvcBuilders.standaloneSetup(workflowVersionController).build(); + } + + @Test + public void shouldReturnWorkflowVersionListWhenCallingVersionGetREST() throws Exception { + + doReturn(versionList).when(workflowVersionManagerMock).list(ITEM1_ID, null); + mockMvc.perform(get(RestPath.getWorkflowVersions(ITEM1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)).andExpect(status().isOk()) + .andExpect(jsonPath("$.results", hasSize(2))) + .andExpect(jsonPath("$.results[0].id", equalTo(VERSION1_ID))) + .andExpect(jsonPath("$.results[1].id", equalTo(VERSION2_ID))); + + verify(workflowVersionManagerMock, times(1)).list(ITEM1_ID, null); + } + + + @Test + public void shouldCreateWorkflowVersionWhenCallingVersionsPostREST() throws Exception { + + WorkflowVersion version = new WorkflowVersion(); + version.setDescription("VersionDescription"); + mockMvc.perform(post(RestPath.getWorkflowVersions(ITEM1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON) + .content(GSON.toJson(version))) + .andExpect(status().isCreated()); + + verify(workflowVersionManagerMock, times(1)).create(ITEM1_ID, null, version); + } + + + @Test + public void shouldReturnWorkflowVersionWhenExists() throws Exception { + WorkflowVersion version = new WorkflowVersion(VERSION1_ID); + doReturn(version).when(workflowVersionManagerMock).get(ITEM1_ID, VERSION1_ID); + mockMvc.perform( + get(RestPath.getWorkflowVersion(ITEM1_ID, VERSION1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON)).andDo(print()) + .andExpect(status().isOk()).andExpect(jsonPath("$.id", is(version.getId()))); + verify(workflowVersionManagerMock, times(1)).get(ITEM1_ID, VERSION1_ID); + } + + @Test + public void shouldUpdateWorkflowVersionWhenCallingPutREST() throws Exception { + WorkflowVersion version = new WorkflowVersion(); + version.setDescription("Updated"); + + MockHttpServletResponse result = mockMvc.perform( + put(RestPath.getWorkflowVersion(ITEM1_ID, VERSION1_ID)).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID) + .contentType(APPLICATION_JSON) + .content(GSON.toJson(version))).andReturn() + .getResponse(); + + assertEquals(HttpStatus.OK.value(), result.getStatus()); + version.setId(VERSION1_ID); + verify(workflowVersionManagerMock, times(1)).update(ITEM1_ID, version); + + } + +} diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java new file mode 100644 index 00000000..b86b14b9 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ArtifactRepositoryTest.java @@ -0,0 +1,99 @@ +package org.onap.sdc.workflow.persistence.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.isNull; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.verify; +import static org.openecomp.core.zusammen.api.ZusammenUtil.buildStructuralElement; + +import com.amdocs.zusammen.adaptor.inbound.api.types.item.Element; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement; +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.item.Action; +import com.amdocs.zusammen.datatypes.item.ElementContext; +import java.io.IOException; +import java.io.InputStream; +import java.util.Optional; +import org.apache.commons.io.IOUtils; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; +import org.onap.sdc.workflow.persistence.types.WorkflowElementType; +import org.openecomp.core.zusammen.api.ZusammenAdaptor; +import org.openecomp.sdc.common.session.SessionContextProviderFactory; + +@RunWith(MockitoJUnitRunner.class) +public class ArtifactRepositoryTest { + + private static final String FILE_NAME_PROPERTY = "fileName"; + private static final String FILE_NAME = "fileName.txt"; + private static final String ITEM1_ID = "item_id_1"; + private static final String VERSION1_ID = "version_id_1"; + + + @Mock + private ZusammenAdaptor zusammenAdaptorMock; + + @InjectMocks + private ArtifactRepositoryImpl artifactRepository; + + @Before + public void setUp() { + SessionContextProviderFactory.getInstance().createInterface().create("test_user", "workflow"); + } + + @Test + public void shouldUpdateArtifact() throws IOException { + + InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8"); + ArtifactEntity artifactMock = new ArtifactEntity(FILE_NAME, inputStreamMock); + + artifactRepository.update(ITEM1_ID, VERSION1_ID, artifactMock); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Update WorkflowVersion Artifact Element")); + } + + @Test + public void shouldGetArtifactWhenExist() throws IOException { + + ZusammenElement artifactElement = buildStructuralElement(WorkflowElementType.ARTIFACT.name(), Action.UPDATE); + artifactElement.setData(IOUtils.toInputStream("some test data for my input stream", "UTF-8")); + artifactElement.getInfo().addProperty(FILE_NAME_PROPERTY, FILE_NAME); + Optional elementOptional = Optional.of(artifactElement); + + doReturn(elementOptional).when(zusammenAdaptorMock) + .getElementByName(any(SessionContext.class), any(ElementContext.class), isNull(Id.class), + eq(WorkflowElementType.ARTIFACT.name())); + + Optional result = artifactRepository.get(ITEM1_ID, VERSION1_ID); + assertTrue(result.isPresent()); + assertEquals(FILE_NAME,result.get().getFileName()); + verify(zusammenAdaptorMock).getElementByName(any(SessionContext.class), any(ElementContext.class), isNull(Id.class), + eq(WorkflowElementType.ARTIFACT.name())); + } + + @Test + public void shouldCreateArtifactStructure() { + artifactRepository.createStructure(ITEM1_ID, VERSION1_ID); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Create WorkflowVersion Artifact Element")); + } + + @Test + public void shouldDeleteArtifact(){ + artifactRepository.delete(ITEM1_ID,VERSION1_ID); + verify(zusammenAdaptorMock).saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Delete WorkflowVersion Artifact Data")); + } + +} diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java new file mode 100644 index 00000000..07a42658 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ParameterRepositoryTest.java @@ -0,0 +1,166 @@ +package org.onap.sdc.workflow.persistence.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.verify; + +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo; +import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement; +import com.amdocs.zusammen.datatypes.Id; +import com.amdocs.zusammen.datatypes.SessionContext; +import com.amdocs.zusammen.datatypes.item.ElementContext; +import com.amdocs.zusammen.datatypes.item.Info; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mapstruct.ap.internal.util.Collections; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.sdc.workflow.persistence.types.ParameterEntity; +import org.onap.sdc.workflow.persistence.types.ParameterPropertyName; +import org.onap.sdc.workflow.persistence.types.ParameterRole; +import org.onap.sdc.workflow.persistence.types.ParameterType; +import org.onap.sdc.workflow.persistence.types.WorkflowElementType; +import org.openecomp.core.zusammen.api.ZusammenAdaptor; +import org.openecomp.sdc.common.session.SessionContextProviderFactory; + +@RunWith(MockitoJUnitRunner.class) +public class ParameterRepositoryTest { + + private static final String ITEM1_ID = "item_id_1"; + private static final String VERSION1_ID = "version_id_1"; + private static final String PARAMETER1_ID = "parameter_id_1"; + private static final String PARAMETER2_ID = "parameter_id_2"; + private static final String PARAMETERS_PARENT_ID = "parameters_id"; + + + @Mock + private ZusammenAdaptor zusammenAdaptorMock; + @Spy + @InjectMocks + private ParameterRepositoryImpl parameterRepository; + + @Before + public void setUp() { + SessionContextProviderFactory.getInstance().createInterface().create("test_user", "workflow"); + } + + @Test + public void shouldGetParameterById() { + + ElementInfo element = new ElementInfo(); + element.setId(new Id(PARAMETER1_ID)); + Info info = new Info(); + info.setName("testInput"); + info.addProperty(ParameterPropertyName.TYPE.name(), ParameterType.FLOAT.name()); + info.addProperty(ParameterPropertyName.mandatory.name(), true); + element.setInfo(info); + doReturn(Optional.of(element)).when(zusammenAdaptorMock) + .getElementInfo(any(SessionContext.class), any(ElementContext.class), + eq(new Id(PARAMETER1_ID))); + ParameterEntity result = parameterRepository.get(ITEM1_ID, VERSION1_ID, PARAMETER1_ID); + verify(zusammenAdaptorMock) + .getElementInfo(any(SessionContext.class), any(ElementContext.class), eq(new Id(PARAMETER1_ID))); + assertEquals("testInput", result.getName()); + + } + + + @Test + public void shouldUpdateParameter() { + ParameterEntity parameterEntityToUpdate = new ParameterEntity(); + parameterEntityToUpdate.setId(PARAMETER1_ID); + parameterEntityToUpdate.setName("Input1"); + parameterEntityToUpdate.setMandatory(true); + parameterEntityToUpdate.setType(ParameterType.STRING); + + parameterRepository.update(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT, parameterEntityToUpdate); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Update WorkflowVersion Parameter")); + + } + + @Test + public void shouldCreateParameterStructure() { + parameterRepository.createStructure(ITEM1_ID, VERSION1_ID); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Create WorkflowVersion INPUTS Element")); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Create WorkflowVersion OUTPUTS Element")); + } + + @Test + public void shouldDeleteParameter() { + parameterRepository.delete(ITEM1_ID, VERSION1_ID, PARAMETER1_ID); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Delete Parameter with id parameter_id_1")); + } + + + @Test + public void shouldListParametersByType() { + + ElementInfo parameter1 = new ElementInfo(); + parameter1.setId(new Id(PARAMETER1_ID)); + Info info1 = new Info(); + info1.setName("input1"); + info1.addProperty(ParameterPropertyName.TYPE.name(), "INTEGER"); + info1.addProperty(ParameterPropertyName.mandatory.name(), true); + parameter1.setInfo(info1); + ElementInfo parameter2 = new ElementInfo(); + parameter2.setId(new Id(PARAMETER2_ID)); + Info info2 = new Info(); + info2.setName("input2"); + info2.addProperty(ParameterPropertyName.TYPE.name(), "STRING"); + info2.addProperty(ParameterPropertyName.mandatory.name(), false); + parameter2.setInfo(info2); + Collection parameters = Collections.asSet(parameter1, parameter2); + doReturn(parameters).when(zusammenAdaptorMock) + .listElementsByName(any(SessionContext.class), any(ElementContext.class), isNull(), + eq(WorkflowElementType.INPUTS.name())); + Collection results = parameterRepository.list(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT); + + verify(zusammenAdaptorMock).listElementsByName(any(SessionContext.class), any(ElementContext.class), isNull(), + eq(WorkflowElementType.INPUTS.name())); + assertTrue(results.stream().anyMatch(parameterEntity -> parameterEntity.getId().equals(PARAMETER1_ID))); + assertTrue(results.stream().anyMatch(parameterEntity -> parameterEntity.getId().equals(PARAMETER2_ID))); + } + + @Test + public void shouldDeleteAllParametersByType() { + ElementInfo parameterParentElement = new ElementInfo(); + parameterParentElement.setId(new Id(PARAMETERS_PARENT_ID)); + ElementInfo parameter1 = new ElementInfo(); + parameter1.setId(new Id(PARAMETER1_ID)); + ElementInfo parameter2 = new ElementInfo(); + parameter2.setId(new Id(PARAMETER2_ID)); + parameterParentElement.setSubElements(new ArrayList<>()); + parameterParentElement.getSubElements().add(parameter1); + parameterParentElement.getSubElements().add(parameter2); + + Optional elementOptional = Optional.of(parameterParentElement); + + doReturn(elementOptional).when(zusammenAdaptorMock) + .getElementInfoByName(any(SessionContext.class), any(ElementContext.class), isNull(), + eq(WorkflowElementType.INPUTS.name())); + + parameterRepository.deleteAll(ITEM1_ID, VERSION1_ID, ParameterRole.INPUT); + verify(zusammenAdaptorMock) + .saveElement(any(SessionContext.class), any(ElementContext.class), any(ZusammenElement.class), + eq("Delete all INPUT")); + } + +} diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java new file mode 100644 index 00000000..4911060a --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/UniqueValueServiceTest.java @@ -0,0 +1,98 @@ +package org.onap.sdc.workflow.services; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.Spy; +import org.onap.sdc.workflow.persistence.UniqueValueRepository; +import org.onap.sdc.workflow.persistence.types.UniqueValueEntity; +import org.onap.sdc.workflow.services.exceptions.UniqueValueViolationException; + +public class UniqueValueServiceTest { + + private static final String TYPE = "ss"; + private static final String DUMMY_COMBINATION = "dummy"; + + @Mock + private UniqueValueRepository uniqueValueRepositoryMock; + + @Spy + @InjectMocks + private UniqueValueService uniqueValueService; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void shouldCallRepositoryInsertIfValueUnique(){ + doReturn(Optional.empty()).when(uniqueValueRepositoryMock).findById(any()); + uniqueValueService.createUniqueValue(TYPE, new String[]{DUMMY_COMBINATION}); + verify(uniqueValueRepositoryMock, times(1)).insert(any(UniqueValueEntity.class)); + } + + @Test + public void shouldNotCheckValueIfNoUniqueCombination(){ + uniqueValueService.createUniqueValue(TYPE, null); + verify(uniqueValueRepositoryMock, never()).findById(any(UniqueValueEntity.class)); + } + + @Test(expected = UniqueValueViolationException.class) + public void shouldThrowExceptionIfValueIsNotUnique(){ + doReturn(Optional.of("xxx")).when(uniqueValueRepositoryMock).findById(any()); + uniqueValueService.createUniqueValue(TYPE, new String[]{DUMMY_COMBINATION}); + } + + @Test + public void shouldCallRepositoryDeleteIfValueValid(){ + uniqueValueService.deleteUniqueValue(TYPE, new String[]{DUMMY_COMBINATION}); + verify(uniqueValueRepositoryMock, times(1)).delete(any(UniqueValueEntity.class)); + } + + @Test + public void shouldNotCallRepositoryDeleteIfValueNouniqueCombination(){ + uniqueValueService.deleteUniqueValue(TYPE, new String[]{}); + verify(uniqueValueRepositoryMock, never()).delete(any(UniqueValueEntity.class)); + } + + @Test + public void shouldNotUpdateIfNewAndOldValueAreEqualsCaseIgnore(){ + String value = "value"; + uniqueValueService.updateUniqueValue(TYPE, value, value.toUpperCase()); + verify(uniqueValueService, never()).createUniqueValue(anyString(), any()); + } + + @Test + public void shouldUpdateIfNewAndOldValueAreNotEqualsCaseIgnore(){ + String oldValue = "oldValue"; + String newValue = "newValue"; + uniqueValueService.updateUniqueValue(TYPE, oldValue, newValue); + verify(uniqueValueService, times(1)).createUniqueValue(anyString(), any()); + verify(uniqueValueService, times(1)).deleteUniqueValue(anyString(), any()); + } + + @Test + public void shouldReturnTrueIfValueExist() { + doReturn(Optional.of("xxx")).when(uniqueValueRepositoryMock).findById(any()); + assertTrue(uniqueValueService.isUniqueValueOccupied(TYPE, new String[]{DUMMY_COMBINATION})); + } + + @Test + public void shouldReturnFalseIfValueNotExist() { + doReturn(Optional.empty()).when(uniqueValueRepositoryMock).findById(any()); + assertFalse(uniqueValueService.isUniqueValueOccupied(TYPE, new String[]{DUMMY_COMBINATION})); + } +} diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java new file mode 100644 index 00000000..0105fe83 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowManagerImplTest.java @@ -0,0 +1,240 @@ +package org.onap.sdc.workflow.services.impl; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.onap.sdc.workflow.TestUtil.createItem; +import static org.onap.sdc.workflow.TestUtil.createWorkflow; +import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME; +import static org.openecomp.sdc.versioning.dao.types.VersionStatus.Certified; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.onap.sdc.workflow.services.UniqueValueService; +import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException; +import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper; +import org.onap.sdc.workflow.services.impl.mappers.WorkflowMapper; +import org.openecomp.sdc.versioning.ItemManager; +import org.openecomp.sdc.versioning.types.Item; +import org.openecomp.sdc.versioning.types.ItemStatus; +import org.springframework.data.domain.PageRequest; +import org.springframework.data.domain.Sort; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +public class WorkflowManagerImplTest { + + private static final String ITEM1_ID = "1"; + private static final String WORKFLOW_TYPE = "WORKFLOW"; + private static final String WORKFLOW_NAME_UNIQUE_TYPE = "WORKFLOW_NAME"; + private static final List ITEMS; + private static final List MAPPED_WORKFLOWS; + + static { + List items = new ArrayList<>(); + List mappedWorkflows = new ArrayList<>(); + for (int i = 1; i < 6; i++) { + items.add(createItem(i, true, true)); + mappedWorkflows.add(createWorkflow(i, true)); + } + ITEMS = Collections.unmodifiableList(items); + MAPPED_WORKFLOWS = Collections.unmodifiableList(mappedWorkflows); + } + + @Mock + private ItemManager itemManagerMock; + @Mock + private UniqueValueService uniqueValueServiceMock; + @Mock + private WorkflowMapper workflowMapperMock; + @Mock + private VersionStateMapper versionStateMapperMock; + @InjectMocks + private WorkflowManagerImpl workflowManager; + + @Test + public void shouldReturnWorkflowVersionList() { + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Collection workflows = + workflowManager.list(null, createPageRequest(20, 0, Sort.Direction.ASC, SORT_FIELD_NAME)); + + Map workflowById = + workflows.stream().collect(Collectors.toMap(Workflow::getId, Function.identity())); + assertEquals(ITEMS.size(), workflows.size()); + for (int i = 1; i < ITEMS.size() + 1; i++) { + assertTrue(workflowById.containsKey(String.valueOf(i))); + } + } + + @Test + public void listWithVersionStateFilter() { + doReturn(Certified).when(versionStateMapperMock) + .workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED); + doReturn(Arrays.asList(ITEMS.get(0), ITEMS.get(2))).when(itemManagerMock).list(any()); + doReturn(MAPPED_WORKFLOWS.get(0)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(0)); + doReturn(MAPPED_WORKFLOWS.get(2)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(2)); + + Collection workflows = workflowManager.list(Collections.singleton(WorkflowVersionState.CERTIFIED), + createPageRequest(20, 0, Sort.Direction.ASC, SORT_FIELD_NAME)); + + Map workflowById = + workflows.stream().collect(Collectors.toMap(Workflow::getId, Function.identity())); + assertEquals(2, workflows.size()); + assertTrue(workflowById.containsKey("1")); + assertTrue(workflowById.containsKey("3")); + } + + @Test(expected = EntityNotFoundException.class) + public void shouldThrowExceptionWhenWorkflowDontExist() { + Workflow nonExistingWorkflow = new Workflow(); + nonExistingWorkflow.setId(ITEM1_ID); + doReturn(null).when(itemManagerMock).get(ITEM1_ID); + workflowManager.get(nonExistingWorkflow); + verify(workflowMapperMock, times(3)).itemToWorkflow(any(Item.class)); + } + + @Test + public void shouldReturnWorkflow() { + Item retrievedItem = createItem(1, true, true); + doReturn(retrievedItem).when(itemManagerMock).get(ITEM1_ID); + Workflow workflow = createWorkflow(1, true); + workflowManager.get(workflow); + verify(itemManagerMock).get(ITEM1_ID); + verify(workflowMapperMock).itemToWorkflow(retrievedItem); + } + + @Test + public void shouldCreateWorkflowItemFromWorkflow() { + Workflow workflowToBeCreated = createWorkflow(1, false); + Item createdWorkflowItem = createItem(1, false, true); + doReturn(createdWorkflowItem).when(workflowMapperMock).workflowToItem(workflowToBeCreated); + doReturn(createdWorkflowItem).when(itemManagerMock).create(createdWorkflowItem); + workflowManager.create(workflowToBeCreated); + verify(uniqueValueServiceMock) + .validateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()}); + + createdWorkflowItem.setStatus(ItemStatus.ACTIVE); + createdWorkflowItem.setType(WORKFLOW_TYPE); + verify(itemManagerMock).create(createdWorkflowItem); + verify(uniqueValueServiceMock) + .createUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, new String[] {workflowToBeCreated.getName()}); + } + + @Test + public void shouldUpdateWorkflow() { + Item workflowItem = createItem(1, true, true); + doReturn(workflowItem).when(itemManagerMock).get(ITEM1_ID); + Workflow workflowToBeUpdated = createWorkflow(1, true); + doReturn(workflowItem).when(workflowMapperMock).workflowToItem(workflowToBeUpdated); + workflowManager.update(workflowToBeUpdated); + verify(itemManagerMock).update(workflowItem); + verify(uniqueValueServiceMock) + .updateUniqueValue(WORKFLOW_NAME_UNIQUE_TYPE, workflowItem.getName(), workflowToBeUpdated.getName()); + + } + + @Test(expected = EntityNotFoundException.class) + public void shouldThrowExceptionWhenWorkflowToUpdateNotFound() { + doReturn(null).when(itemManagerMock).get(ITEM1_ID); + workflowManager.update(createWorkflow(1, true)); + } + + @Test + public void shouldListAllWorkflowsWhenLimitAndOffsetAreValid() { + PageRequest pageRequest = createPageRequest(5, 0, Sort.Direction.ASC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Assert.assertEquals(5, workflowManager.list(null, pageRequest).size()); + } + + @Test + public void shouldListLimitFilteredWorkflowsInFirstOffsetRange() { + PageRequest pageRequest = createPageRequest(3, 0, Sort.Direction.ASC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Assert.assertEquals(3, workflowManager.list(null, pageRequest).size()); + } + + @Test + public void shouldListLimitFilteredWorkflowsInSecondOffsetRange() { + PageRequest pageRequest = createPageRequest(3, 1, Sort.Direction.ASC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Assert.assertEquals(2, workflowManager.list(null, pageRequest).size()); + } + + @Test + public void shouldListAllWorkflowsWhenLimitGreaterThanTotalRecordsAndOffsetInRange() { + PageRequest pageRequest = createPageRequest(10, 0, Sort.Direction.ASC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Assert.assertEquals(5, workflowManager.list(null, pageRequest).size()); + } + + @Test + public void shouldNotListWorkflowsIfOffsetGreaterThanTotalRecords() { + PageRequest pageRequest = createPageRequest(3, 6, Sort.Direction.ASC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Assert.assertEquals(0, workflowManager.list(null, pageRequest).size()); + } + + @Test + public void shouldNotListWorkflowsBothLimitAndOffsetGreaterThanTotalRecords() { + PageRequest pageRequest = createPageRequest(10, 10, Sort.Direction.ASC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Assert.assertEquals(0, workflowManager.list(null, pageRequest).size()); + } + + @Test + public void shouldListLimitOffsetAppliedWorkflowsSortedInDescOrder() { + PageRequest pageRequest = createPageRequest(2, 1, Sort.Direction.DESC, SORT_FIELD_NAME); + doReturn(ITEMS).when(itemManagerMock).list(any()); + for (int i = 0; i < ITEMS.size(); i++) { + doReturn(MAPPED_WORKFLOWS.get(i)).when(workflowMapperMock).itemToWorkflow(ITEMS.get(i)); + } + Collection workflows = workflowManager.list(null, pageRequest); + Assert.assertEquals(2, workflows.size()); + Iterator workflowIterator = workflows.iterator(); + Assert.assertEquals("Workflow_3", workflowIterator.next().getName()); + Assert.assertEquals("Workflow_2", workflowIterator.next().getName()); + } + + private PageRequest createPageRequest(int limit, int offset, Sort.Direction sortOrder, String sortField) { + return PageRequest.of(offset, limit, sortOrder, sortField); + } + +} \ No newline at end of file diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java new file mode 100644 index 00000000..7dee5245 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/WorkflowVersionManagerImplTest.java @@ -0,0 +1,264 @@ +package org.onap.sdc.workflow.services.impl; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.CERTIFIED; +import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.DRAFT; + +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import org.apache.commons.io.IOUtils; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.ArgumentMatcher; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnitRunner; +import org.onap.sdc.workflow.persistence.ArtifactRepository; +import org.onap.sdc.workflow.persistence.ParameterRepository; +import org.onap.sdc.workflow.persistence.types.ArtifactEntity; +import org.onap.sdc.workflow.persistence.types.ParameterRole; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException; +import org.onap.sdc.workflow.services.exceptions.VersionCreationException; +import org.onap.sdc.workflow.services.exceptions.VersionStateModificationException; +import org.onap.sdc.workflow.services.impl.mappers.VersionMapper; +import org.onap.sdc.workflow.services.impl.mappers.VersionStateMapper; +import org.openecomp.sdc.versioning.VersioningManager; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; +import org.openecomp.sdc.versioning.types.VersionCreationMethod; +import org.springframework.mock.web.MockMultipartFile; + +@RunWith(MockitoJUnitRunner.class) +public class WorkflowVersionManagerImplTest { + + private static final String ITEM1_ID = "item_id_1"; + private static final String VERSION1_ID = "version_id_1"; + private static final String VERSION2_ID = "version_id_2"; + + @Mock + private VersioningManager versioningManagerMock; + @Mock + private ParameterRepository parameterRepositoryMock; + @Mock + private ArtifactRepository artifactRepositoryMock; + @Mock + private VersionMapper versionMapperMock; + @Mock + private VersionStateMapper versionStateMapperMock; + @Spy + @InjectMocks + private WorkflowVersionManagerImpl workflowVersionManager; + + @Test(expected = EntityNotFoundException.class) + public void shouldThrowExceptionWhenVersionDontExist() { + Version nonExistingVersion = new Version(VERSION1_ID); + doThrow(new RuntimeException()).when(versioningManagerMock).get(ITEM1_ID, nonExistingVersion); + workflowVersionManager.get(ITEM1_ID, VERSION1_ID); + } + + @Test + public void shouldReturnWorkflowVersionWhenExist() { + Version version = new Version(VERSION1_ID); + WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID); + doReturn(workflowVersion).when(versionMapperMock).versionToWorkflowVersion(any(Version.class)); + doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID),any(Version.class)); + doReturn(new ArrayList()).when(parameterRepositoryMock).list(eq(ITEM1_ID), eq(VERSION1_ID), any(ParameterRole.class)); + workflowVersionManager.get(ITEM1_ID,VERSION1_ID); + verify(versioningManagerMock).get(ITEM1_ID,version); + } + + @Test + public void shouldReturnWorkflowVersionList() { + List versionList = Arrays.asList(new Version(VERSION1_ID), new Version(VERSION2_ID)); + doReturn(versionList).when(versioningManagerMock).list(ITEM1_ID); + doReturn(new WorkflowVersion()).when(versionMapperMock).versionToWorkflowVersion(any(Version.class)); + workflowVersionManager.list(ITEM1_ID, null); + verify(versioningManagerMock).list(ITEM1_ID); + verify(versionMapperMock, times(2)).versionToWorkflowVersion(any(Version.class)); + } + + @Test + public void shouldUpdateWorkflowVersion() { + String updatedDescription = "WorkflowVersion description updated"; + Version retrievedVersion = new Version(VERSION1_ID); + retrievedVersion.setName("1.0"); + retrievedVersion.setDescription("WorkflowVersion description"); + retrievedVersion.setStatus(VersionStatus.Draft); + doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(retrievedVersion.getStatus()); + + WorkflowVersion inputVersion = new WorkflowVersion(VERSION1_ID); + inputVersion.setName("1.0"); + inputVersion.setDescription(updatedDescription); + inputVersion.setInputs(new ArrayList<>()); + inputVersion.setOutputs(new ArrayList<>()); + + Version mappedInputVersion = new Version(VERSION1_ID); + mappedInputVersion.setName("1.0"); + mappedInputVersion.setDescription(updatedDescription); + doReturn(mappedInputVersion).when(versionMapperMock).workflowVersionToVersion(inputVersion); + + ArgumentCaptor versionArgCaptor = ArgumentCaptor.forClass(Version.class); + workflowVersionManager.update(ITEM1_ID, inputVersion); + + verify(versioningManagerMock).updateVersion(eq(ITEM1_ID), versionArgCaptor.capture()); + Version captorVersion = versionArgCaptor.getValue(); + assertEquals("1.0", captorVersion.getName()); + assertEquals(updatedDescription, captorVersion.getDescription()); + assertEquals(VersionStatus.Draft, captorVersion.getStatus()); + verify(versioningManagerMock).publish(ITEM1_ID, mappedInputVersion, "Update version"); + } + + + @Test + public void shouldCreateWorkflowVersion(){ + Version version = new Version(VERSION1_ID); + version.setDescription("version desc"); + doReturn(version).when(versioningManagerMock).create(ITEM1_ID,version, VersionCreationMethod.major); + WorkflowVersion versionRequest = new WorkflowVersion(); + versionRequest.setDescription("version desc"); + versionRequest.setInputs(new ArrayList<>()); + versionRequest.setOutputs(new ArrayList<>()); + WorkflowVersion workflowVersion = new WorkflowVersion(VERSION1_ID); + doReturn(workflowVersion).when(workflowVersionManager).get(ITEM1_ID,VERSION1_ID); + workflowVersionManager.create(ITEM1_ID, null, versionRequest); + verify(versioningManagerMock).create(ITEM1_ID,version, VersionCreationMethod.major); + } + + @Test(expected = VersionCreationException.class) + public void shouldTrowExceptionWhenDraftVersionExists() { + WorkflowVersion versionRequestDto = new WorkflowVersion(); + + Version baseVersion = new Version(VERSION2_ID); + baseVersion.setStatus(VersionStatus.Draft); + List versions = Collections.singletonList(baseVersion); + doReturn(versions).when(versioningManagerMock).list(ITEM1_ID); + + workflowVersionManager.create(ITEM1_ID, VERSION2_ID, versionRequestDto); + } + + @Test(expected = EntityNotFoundException.class) + public void getStateOfNonExisting() { + doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + workflowVersionManager.getState(ITEM1_ID, VERSION1_ID); + } + + @Test + public void getState() { + Version version = new Version(VERSION1_ID); + version.setStatus(VersionStatus.Certified); + doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus()); + + WorkflowVersionState state = workflowVersionManager.getState(ITEM1_ID, VERSION1_ID); + assertEquals(CERTIFIED, state); + } + + @Test(expected = EntityNotFoundException.class) + public void updateStateOfNonExisting() { + doThrow(new RuntimeException()).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED); + } + + @Test(expected = VersionStateModificationException.class) + public void updateStateToCurrentState() { + Version version = new Version(VERSION1_ID); + version.setStatus(VersionStatus.Draft); + doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus()); + + workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, DRAFT); + } + + @Test(expected = VersionStateModificationException.class) + public void updateStateWhenCertified() { + Version version = new Version(VERSION1_ID); + version.setStatus(VersionStatus.Certified); + doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + doReturn(CERTIFIED).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus()); + doThrow(new RuntimeException()).when(versioningManagerMock) + .submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString()); + + workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED); + } + + @Test + public void updateState() { + Version retrievedVersion = new Version(VERSION1_ID); + retrievedVersion.setStatus(VersionStatus.Draft); + doReturn(retrievedVersion).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(VersionStatus.Draft); + + workflowVersionManager.updateState(ITEM1_ID, VERSION1_ID, CERTIFIED); + + verify(versioningManagerMock).submit(eq(ITEM1_ID), eqVersion(VERSION1_ID), anyString()); + } + + @Test + public void shouldUploadArtifact() { + Version version = new Version(VERSION1_ID); + version.setStatus(VersionStatus.Draft); + doReturn(version).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + doReturn(DRAFT).when(versionStateMapperMock).versionStatusToWorkflowVersionState(version.getStatus()); + + MockMultipartFile mockFile = new MockMultipartFile("data", "filename.txt", "text/plain", "some xml".getBytes()); + workflowVersionManager.uploadArtifact(ITEM1_ID, VERSION1_ID, mockFile); + + verify(artifactRepositoryMock).update(eq(ITEM1_ID), eq(VERSION1_ID), any(ArtifactEntity.class)); + } + + @Test(expected = EntityNotFoundException.class) + public void shouldThrowExceptionWhenArtifactNotFound() { + doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + + doReturn(Optional.empty()).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID); + workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID); + } + + @Test + public void shouldReturnArtifact() throws IOException { + doReturn(new Version(VERSION1_ID)).when(versioningManagerMock).get(eq(ITEM1_ID), eqVersion(VERSION1_ID)); + + InputStream inputStreamMock = IOUtils.toInputStream("some test data for my input stream", "UTF-8"); + ArtifactEntity artifactMock = new ArtifactEntity("fileName.txt", inputStreamMock); + doReturn(Optional.of(artifactMock)).when(artifactRepositoryMock).get(ITEM1_ID, VERSION1_ID); + ArtifactEntity returnedArtifact = workflowVersionManager.getArtifact(ITEM1_ID, VERSION1_ID); + assertEquals(artifactMock, returnedArtifact); + } + + private static Version eqVersion(String versionId) { + return argThat(new EqVersion(versionId)); + } + + private static class EqVersion implements ArgumentMatcher { + + private final String versionId; + + EqVersion(String versionId) { + this.versionId = versionId; + } + + @Override + public boolean matches(Version version) { + return versionId.equals(version.getId()); + } + } + +} \ No newline at end of file diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java new file mode 100644 index 00000000..d9790355 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionMapperTest.java @@ -0,0 +1,80 @@ +package org.onap.sdc.workflow.services.impl.mappers; + +import static org.junit.Assert.assertEquals; + +import java.util.Date; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.sdc.workflow.persistence.types.WorkflowVersion; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.openecomp.sdc.versioning.dao.types.Version; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@ContextConfiguration(classes = VersionMapperTest.VersionMapperSpringTestConfig.class) +@RunWith(SpringJUnit4ClassRunner.class) +public class VersionMapperTest { + + @Configuration + @ComponentScan(basePackageClasses = {VersionMapper.class, VersionStateMapper.class}) + public static class VersionMapperSpringTestConfig { } + + @Autowired + VersionMapper versionMapper; + + + @Test + public void shouldMapVersionToWorkflowVersion() { + Version version = createVersion(); + WorkflowVersion mappedWorkflowVersion = versionMapper.versionToWorkflowVersion(version); + assertEquals(mappedWorkflowVersion.getId(), version.getId()); + assertEquals(mappedWorkflowVersion.getBaseId(), version.getBaseId()); + assertEquals(mappedWorkflowVersion.getDescription(), version.getDescription()); + assertEquals(mappedWorkflowVersion.getName(), version.getName()); + assertEquals(mappedWorkflowVersion.getCreationTime(), version.getCreationTime()); + assertEquals(mappedWorkflowVersion.getModificationTime(), version.getModificationTime()); + } + + @Test + public void shouldMapWorkflowVersionToVersion() { + WorkflowVersion workflowVersion = createWorkflowVersion(); + Version mappedVersion = versionMapper.workflowVersionToVersion(workflowVersion); + assertEquals(mappedVersion.getId(), workflowVersion.getId()); + assertEquals(mappedVersion.getBaseId(), workflowVersion.getBaseId()); + assertEquals(mappedVersion.getDescription(), workflowVersion.getDescription()); + assertEquals(mappedVersion.getName(), workflowVersion.getName()); + assertEquals(mappedVersion.getCreationTime(), workflowVersion.getCreationTime()); + assertEquals(mappedVersion.getModificationTime(), workflowVersion.getModificationTime()); + + } + + private Version createVersion() { + Version version = new Version("version_id"); + version.setBaseId("base_version_id"); + version.setName("1.0"); + version.setCreationTime(new Date()); + version.setModificationTime(new Date()); + version.setDescription("version_description"); + version.setStatus(VersionStatus.Draft); + + return version; + + } + + private WorkflowVersion createWorkflowVersion() { + WorkflowVersion workflowVersion = new WorkflowVersion(); + workflowVersion.setId("wf_version_id"); + workflowVersion.setBaseId("wf_base_version_id"); + workflowVersion.setName("1.0"); + workflowVersion.setCreationTime(new Date()); + workflowVersion.setModificationTime(new Date()); + workflowVersion.setDescription("version_description"); + workflowVersion.setState(WorkflowVersionState.CERTIFIED); + + return workflowVersion; + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java new file mode 100644 index 00000000..070c433e --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/VersionStateMapperTest.java @@ -0,0 +1,75 @@ +package org.onap.sdc.workflow.services.impl.mappers; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.sdc.workflow.persistence.types.WorkflowVersionState; +import org.openecomp.sdc.versioning.dao.types.VersionStatus; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@ContextConfiguration(classes = VersionStateMapperTest.VersionStatusMapperSpringTestConfig.class) +@RunWith(SpringJUnit4ClassRunner.class) +public class VersionStateMapperTest { + + @Configuration + @ComponentScan(basePackageClasses = {VersionStateMapper.class}) + public static class VersionStatusMapperSpringTestConfig { } + + + @Autowired + VersionStateMapper versionStateMapper; + + @Test + public void shouldMapCertifiedVersionStatusToWorkflowVersionStatus() { + WorkflowVersionState mappedVersionStatus = + versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Certified); + assertEquals(WorkflowVersionState.CERTIFIED, mappedVersionStatus); + } + + @Test + public void shouldMapDraftVersionStatusToWorkflowVersionStatus() { + WorkflowVersionState mappedVersionStatus = + versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Draft); + assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus); + } + + @Test + public void shouldMapDeletedVersionStatusToWorkflowVersionStatus() { + WorkflowVersionState mappedVersionStatus = + versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Deleted); + assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus); + } + + @Test + public void shouldMapLockedVersionStatusToWorkflowVersionStatus() { + WorkflowVersionState mappedVersionStatus = + versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Locked); + assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus); + } + + @Test + public void shouldMapDeprecatedVersionStatusToWorkflowVersionStatus() { + WorkflowVersionState mappedVersionStatus = + versionStateMapper.versionStatusToWorkflowVersionState(VersionStatus.Deprecated); + assertEquals(WorkflowVersionState.DRAFT, mappedVersionStatus); + } + + @Test + public void shouldMapCertifiedWorkflowVersionStatusToVersionStatus() { + VersionStatus mappedVersionStatus = + versionStateMapper.workflowVersionStateToVersionStatus(WorkflowVersionState.CERTIFIED); + assertEquals(VersionStatus.Certified, mappedVersionStatus); + } + + @Test + public void shouldMapDraftWorkflowVersionStatusToVersionStatus() { + VersionStatus mappedVersionStatus = + versionStateMapper.workflowVersionStateToVersionStatus(WorkflowVersionState.DRAFT); + assertEquals(VersionStatus.Draft, mappedVersionStatus); + } +} \ No newline at end of file diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java new file mode 100644 index 00000000..55802cc0 --- /dev/null +++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/mappers/WorkflowMapperTest.java @@ -0,0 +1,50 @@ +package org.onap.sdc.workflow.services.impl.mappers; + + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.onap.sdc.workflow.TestUtil.createItem; +import static org.onap.sdc.workflow.TestUtil.createWorkflow; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.sdc.workflow.persistence.types.Workflow; +import org.openecomp.sdc.versioning.types.Item; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@ContextConfiguration(classes = WorkflowMapperTest.WorkflowMapperSpringTestConfig.class) +@RunWith(SpringJUnit4ClassRunner.class) +public class WorkflowMapperTest { + + @Configuration + @ComponentScan(basePackageClasses = {WorkflowMapper.class}) + public static class WorkflowMapperSpringTestConfig { } + + @Autowired + WorkflowMapper workflowMapper; + + @Test + public void shouldMapItemToWorkflow() { + + Item item = createItem(1,false,true); + Workflow mappedWorkflow = workflowMapper.itemToWorkflow(item); + assertEquals(mappedWorkflow.getId(), item.getId()); + assertEquals(mappedWorkflow.getDescription(), item.getDescription()); + assertEquals(mappedWorkflow.getName(), item.getName()); + } + + @Test + public void shouldMapWorkflowToItem(){ + + Workflow workflow = createWorkflow(1,true); + Item mappedItem = workflowMapper.workflowToItem(workflow); + assertEquals(mappedItem.getId(), workflow.getId()); + assertEquals(mappedItem.getDescription(), workflow.getDescription()); + assertEquals(mappedItem.getName(), workflow.getName()); + } + +} \ No newline at end of file -- cgit 1.2.3-korg