Add activity spec code

Move code from sdc repository and:
1. place according to this project structure
2. refactor DTOs and use mapstruct
3. change errorResponse to be a json instead of a string (for all workflow code)

Change-Id: Ia85590b53ab59ff7600e05b8a6d52e06b1773220
Issue-ID: SDC-1606
Signed-off-by: talig <talig@amdocs.com>

15 files changed, 740 insertions, 91 deletions

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
index 4301feb8..6c825f9d 100644
--- 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
@@ -10,8 +10,7 @@ public class 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 WORKFLOWS_URL = "/wf/workflows";
     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";
@@ -21,8 +20,6 @@ public class RestPath {
     private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_ALL =
             WORKFLOWS_URL + "?" + SORT_QUERY_STRING_FORMATTER+ "&" +  LIMIT_QUERY_STRING_FORMATTER + "&" +
                     OFFSET_QUERY_STRING_FORMATTER;
-    private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT =
-            WORKFLOWS_URL + "?" + LIMIT_QUERY_STRING_FORMATTER + "&" + OFFSET_QUERY_STRING_FORMATTER;
     private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_LIMIT =
             WORKFLOWS_URL + "?" + OFFSET_QUERY_STRING_FORMATTER;
     private static final String WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_OFFSET =
@@ -32,10 +29,6 @@ public class RestPath {
         return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_ALL, sort, limit, offset);
     }
 
-    public static String getWorkflowsPathNoSort(String limit, String offset){
-        return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT, limit, offset);
-    }
-
     public static String getWorkflowsPathNoSortAndLimit(String offset){
         return String.format(WORKFLOW_URL_FORMATTER_QUERY_PARAMS_NO_SORT_AND_LIMIT, offset);
     }
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
index e2a566aa..0a8355c9 100644
--- 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
@@ -1,12 +1,12 @@
 package org.onap.sdc.workflow;
 
-import org.onap.sdc.workflow.persistence.types.Workflow;
+import static org.onap.sdc.workflow.services.impl.ItemType.WORKFLOW;
+
+import org.onap.sdc.workflow.services.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) {
@@ -26,7 +26,7 @@ public class TestUtil {
         item.setName("Workflow_" + itemNum);
         item.setDescription("Description_" + itemNum);
         if (setType) {
-            item.setType(WORKFLOW_TYPE);
+            item.setType(WORKFLOW.name());
         }
         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
index f8d2aec8..3438093d 100644
--- 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
@@ -32,15 +32,13 @@ 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.persistence.types.Workflow;
+import org.onap.sdc.workflow.services.types.Workflow;
 import org.onap.sdc.workflow.services.WorkflowManager;
 import org.onap.sdc.workflow.services.types.Page;
 import org.onap.sdc.workflow.services.types.PagingRequest;
 import org.onap.sdc.workflow.services.types.RequestSpec;
 import org.onap.sdc.workflow.services.types.Sort;
 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.ResultActions;
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
@@ -48,16 +46,14 @@ 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 String MISSING_USER_HEADER_ERROR =
+            "Missing request header 'USER_ID' for method parameter of type String";
     private static final Gson GSON = new Gson();
     private static final String DEFAULT_SORT_VALUE = "name:asc";
 
     private MockMvc mockMvc;
 
-
     @Mock
     private WorkflowManager workflowManagerMock;
     @Captor
@@ -65,23 +61,19 @@ public class WorkflowControllerTest {
     @InjectMocks
     private WorkflowController workflowController;
 
-
     @Before
     public void setUp() {
         mockMvc = MockMvcBuilders.standaloneSetup(workflowController)
                                  .setCustomArgumentResolvers(new PageableHandlerMethodArgumentResolver())
-                                 .setControllerAdvice(new CustomizedResponseEntityExceptionHandler()).build();
+                                 .setControllerAdvice(new ExceptionsHandler()).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());
+        mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isBadRequest())
+               .andExpect(jsonPath("$.message", is(MISSING_USER_HEADER_ERROR)));
     }
 
     @Test
@@ -96,11 +88,8 @@ public class WorkflowControllerTest {
 
     @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),
-                response.getContentAsString());
+        mockMvc.perform(get(RestPath.getWorkflowsPath()).contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isBadRequest()).andExpect(jsonPath("$.message", is(MISSING_USER_HEADER_ERROR)));
     }
 
     @Test
@@ -205,23 +194,17 @@ public class WorkflowControllerTest {
 
     @Test
     public void shouldThrowExceptionWhenWorkflowNameInvalid() throws Exception {
-
         Workflow reqWorkflow = new Workflow();
         reqWorkflow.setName("Invalid workflow name %");
-        MockHttpServletResponse response = mockMvc.perform(
-                post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)
-                                                 .content(GSON.toJson(reqWorkflow))).andDo(print())
-                                                  .andExpect(status().isBadRequest()).andReturn().getResponse();
-        assertEquals("Workflow name must contain only letters, digits and underscores", response.getContentAsString());
+        mockMvc.perform(post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)
+                                                         .content(GSON.toJson(reqWorkflow))).andDo(print())
+               .andExpect(status().isBadRequest())
+               .andExpect(jsonPath("$.message", is("Workflow name must contain only letters, digits and underscores")));
     }
 
     private void mockManagerList3() {
-        doReturn(new Page<>(Arrays.asList(
-                createWorkflow(1, true),
-                createWorkflow(2, true),
-                createWorkflow(3, true)),
-                new PagingRequest(DEFAULT_OFFSET, DEFAULT_LIMIT), 3))
-                .when(workflowManagerMock).list(any(), any());
+        doReturn(new Page<>(Arrays.asList(createWorkflow(1, true), createWorkflow(2, true), createWorkflow(3, true)),
+                new PagingRequest(DEFAULT_OFFSET, DEFAULT_LIMIT), 3)).when(workflowManagerMock).list(any(), any());
     }
 
     private static void assertRequestSpec(RequestSpec actual, int expectedOffset, int expectedLimit,
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
index 65dae726..2b3c49c1 100644
--- 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
@@ -1,5 +1,6 @@
 package org.onap.sdc.workflow.api;
 
+import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.doReturn;
@@ -16,7 +17,6 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
 import com.google.gson.Gson;
 import java.util.Arrays;
 import java.util.Collection;
-import java.util.List;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -26,8 +26,8 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.onap.sdc.workflow.RestPath;
 import org.onap.sdc.workflow.persistence.types.ParameterEntity;
 import org.onap.sdc.workflow.persistence.types.ParameterType;
-import org.onap.sdc.workflow.persistence.types.WorkflowVersion;
 import org.onap.sdc.workflow.services.WorkflowVersionManager;
+import org.onap.sdc.workflow.services.types.WorkflowVersion;
 import org.openecomp.sdc.versioning.dao.types.Version;
 import org.springframework.http.HttpStatus;
 import org.springframework.mock.web.MockHttpServletResponse;
@@ -58,14 +58,26 @@ public class WorkflowVersionControllerTest {
     }
 
     @Test
+    public void shouldReturnWorkflowVersionListWhenCallingVersionGetREST() throws Exception {
+        doReturn(Arrays.asList(new Version(VERSION1_ID), new Version(VERSION2_ID))).when(workflowVersionManagerMock)
+                .list(ITEM1_ID, null);
+        mockMvc.perform(get(RestPath.getWorkflowVersions(ITEM1_ID)).header(RestParams.USER_ID_HEADER, USER_ID)
+                                .contentType(APPLICATION_JSON)).andExpect(status().isOk())
+                .andExpect(jsonPath("$.items", hasSize(2))).andExpect(jsonPath("$.items[0].id", is(VERSION1_ID)))
+                .andExpect(jsonPath("$.items[1].id", is(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(RestParams.USER_ID_HEADER, USER_ID)
-                                                                    .contentType(APPLICATION_JSON)
-                                                                    .content(GSON.toJson(version)))
-               .andExpect(status().isCreated());
+                                .contentType(APPLICATION_JSON).content(GSON.toJson(version)))
+                .andExpect(status().isCreated());
 
         verify(workflowVersionManagerMock, times(1)).create(ITEM1_ID, null, version);
     }
@@ -79,9 +91,8 @@ public class WorkflowVersionControllerTest {
         version.setInputs(inputs);
         version.setDescription("VersionDescription");
         mockMvc.perform(post(RestPath.getWorkflowVersions(ITEM1_ID)).header(RestParams.USER_ID_HEADER, USER_ID)
-                                                                    .contentType(APPLICATION_JSON)
-                                                                    .content(GSON.toJson(version)))
-               .andExpect(status().isBadRequest());
+                                .contentType(APPLICATION_JSON).content(GSON.toJson(version)))
+                .andExpect(status().isBadRequest());
 
     }
 
@@ -92,8 +103,8 @@ public class WorkflowVersionControllerTest {
         doReturn(version).when(workflowVersionManagerMock).get(ITEM1_ID, VERSION1_ID);
         mockMvc.perform(
                 get(RestPath.getWorkflowVersion(ITEM1_ID, VERSION1_ID)).header(RestParams.USER_ID_HEADER, USER_ID)
-                                                                       .contentType(APPLICATION_JSON)).andDo(print())
-               .andExpect(status().isOk()).andExpect(jsonPath("$.id", is(version.getId())));
+                        .contentType(APPLICATION_JSON)).andDo(print()).andExpect(status().isOk())
+                .andExpect(jsonPath("$.id", is(version.getId())));
         verify(workflowVersionManagerMock, times(1)).get(ITEM1_ID, VERSION1_ID);
     }
 
@@ -104,9 +115,7 @@ public class WorkflowVersionControllerTest {
 
         MockHttpServletResponse result = mockMvc.perform(
                 put(RestPath.getWorkflowVersion(ITEM1_ID, VERSION1_ID)).header(RestParams.USER_ID_HEADER, USER_ID)
-                                                                       .contentType(APPLICATION_JSON)
-                                                                       .content(GSON.toJson(version))).andReturn()
-                                                .getResponse();
+                        .contentType(APPLICATION_JSON).content(GSON.toJson(version))).andReturn().getResponse();
 
         assertEquals(HttpStatus.OK.value(), result.getStatus());
         version.setId(VERSION1_ID);
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/types/VersionStatesFormatterTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/types/VersionStatesFormatterTest.java
index 423c5e6c..c40aef3e 100644
--- a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/types/VersionStatesFormatterTest.java
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/types/VersionStatesFormatterTest.java
@@ -2,8 +2,8 @@ package org.onap.sdc.workflow.api.types;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.CERTIFIED;
-import static org.onap.sdc.workflow.persistence.types.WorkflowVersionState.DRAFT;
+import static org.onap.sdc.workflow.services.types.WorkflowVersionState.CERTIFIED;
+import static org.onap.sdc.workflow.services.types.WorkflowVersionState.DRAFT;
 
 import java.util.Collections;
 import java.util.stream.Collectors;
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ActivitySpecRepositoryImplTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ActivitySpecRepositoryImplTest.java
new file mode 100644
index 00000000..999097c2
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/persistence/impl/ActivitySpecRepositoryImplTest.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.persistence.impl;
+
+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.ElementConflict;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ElementInfo;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ItemVersionConflict;
+import com.amdocs.zusammen.adaptor.inbound.api.types.item.ZusammenElement;
+import com.amdocs.zusammen.commons.health.data.HealthInfo;
+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 com.amdocs.zusammen.datatypes.item.Item;
+import com.amdocs.zusammen.datatypes.item.ItemVersion;
+import com.amdocs.zusammen.datatypes.item.ItemVersionData;
+import com.amdocs.zusammen.datatypes.item.ItemVersionStatus;
+import com.amdocs.zusammen.datatypes.item.Resolution;
+import com.amdocs.zusammen.datatypes.itemversion.ItemVersionRevisions;
+import com.amdocs.zusammen.datatypes.itemversion.Tag;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.onap.sdc.workflow.persistence.impl.ActivitySpecRepositoryImpl.InfoPropertyName;
+import org.onap.sdc.workflow.persistence.impl.types.ActivitySpecData;
+import org.onap.sdc.workflow.persistence.impl.types.ActivitySpecElementType;
+import org.onap.sdc.workflow.persistence.types.ActivitySpecEntity;
+import org.onap.sdc.workflow.persistence.types.ActivitySpecParameter;
+import org.openecomp.core.utilities.json.JsonUtil;
+import org.openecomp.core.zusammen.api.ZusammenAdaptor;
+import org.openecomp.sdc.common.session.SessionContextProviderFactory;
+import org.openecomp.sdc.versioning.dao.types.Version;
+import org.openecomp.types.ElementPropertyName;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+@RunWith(SpringJUnit4ClassRunner.class)
+public class ActivitySpecRepositoryImplTest {
+
+    private static final Version version = new Version();
+    private static final String versionId = "1234";
+    private static final String itemId = "5678";
+    private static final String tenant = "dox";
+
+    private ZusammenAdaptorMock zusammenAdaptor;
+    private ActivitySpecRepositoryImpl daoImpl;
+    private ActivitySpecEntity entity;
+
+
+    @Before
+    public void setUp() {
+        SessionContextProviderFactory.getInstance().createInterface().create("test", tenant);
+        zusammenAdaptor = new ZusammenAdaptorMock();
+        daoImpl = new ActivitySpecRepositoryImpl(zusammenAdaptor);
+        entity = new ActivitySpecEntity();
+        entity = new ActivitySpecEntity();
+
+        entity.setId(itemId);
+        version.setId(versionId);
+        entity.setVersion(version);
+        entity.setName("activitySpec");
+        List<String> categoryList = new ArrayList<>();
+        categoryList.add("category1");
+        entity.setCategoryList(categoryList);
+        ActivitySpecParameter inputParams = new ActivitySpecParameter("dbhost", "String", null);
+        inputParams.setValue("localhost");
+        List<ActivitySpecParameter> inputs = new ArrayList<>();
+        inputs.add(inputParams);
+        entity.setInputs(inputs);
+    }
+
+    @After
+    public void tearDown() {
+        SessionContextProviderFactory.getInstance().createInterface().close();
+    }
+
+    @Test
+    public void testCreate() {
+        ItemVersion itemVersionmock = new ItemVersion();
+        itemVersionmock.setId(new Id());
+
+        daoImpl.create(entity);
+        SessionContext context = createSessionContext();
+        ElementContext elementContext = new ElementContext(entity.getId(), entity.getVersion().getId());
+        Optional<ElementInfo> testElementInfo = zusammenAdaptor.getElementInfoByName(context, elementContext, Id.ZERO,
+                ActivitySpecElementType.ACTIVITYSPEC.name());
+        Assert.assertTrue(testElementInfo.isPresent());
+        Assert.assertEquals(testElementInfo.get().getInfo().getName(), ActivitySpecElementType.ACTIVITYSPEC.name());
+        Assert.assertEquals(testElementInfo.get().getInfo()
+                                    .getProperty(ActivitySpecRepositoryImpl.InfoPropertyName.DESCRIPTION.getValue()),
+                entity.getDescription());
+        Assert.assertEquals(testElementInfo.get().getInfo().getProperty(InfoPropertyName.CATEGORY.getValue()),
+                entity.getCategoryList());
+        Assert.assertEquals(testElementInfo.get().getInfo()
+                                    .getProperty(ActivitySpecRepositoryImpl.InfoPropertyName.NAME.getValue()),
+                entity.getName());
+
+        final Optional<Element> testElement =
+                zusammenAdaptor.getElement(context, elementContext, zusammenAdaptor.elementId);
+        final InputStream data = testElement.get().getData();
+        final ActivitySpecData activitySpecData = JsonUtil.json2Object(data, ActivitySpecData.class);
+        Assert.assertEquals(activitySpecData.getInputs().get(0).getName(), entity.getInputs().get(0).getName());
+    }
+
+    @Test
+    public void testGet() {
+        final ActivitySpecEntity retrieved = daoImpl.get(entity);
+        Assert.assertEquals(retrieved.getName(), entity.getName());
+        Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
+        Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
+    }
+
+    @Test
+    public void testUpdate() {
+        entity.setDescription("Update AS version1");
+        daoImpl.update(entity);
+        final ActivitySpecEntity retrieved = daoImpl.get(entity);
+        Assert.assertEquals(retrieved.getName(), entity.getName());
+        Assert.assertEquals(retrieved.getDescription(), entity.getDescription());
+        Assert.assertEquals(retrieved.getCategoryList(), entity.getCategoryList());
+    }
+
+    private class ZusammenAdaptorMock implements ZusammenAdaptor {
+
+        private final Map<String, Element> elementMap = new HashMap<>();
+        String elementId;
+        private ItemVersion itemVersion;
+
+        @Override
+        public Collection<Item> listItems(SessionContext context) {
+            return null;
+        }
+
+        @Override
+        public Item getItem(SessionContext context, Id itemId) {
+            return null;
+        }
+
+        @Override
+        public void deleteItem(SessionContext context, Id itemId) {
+
+        }
+
+        @Override
+        public Id createItem(SessionContext context, Info info) {
+            return null;
+        }
+
+        @Override
+        public void updateItem(SessionContext context, Id itemId, Info info) {
+
+        }
+
+        @Override
+        public Optional<ItemVersion> getFirstVersion(SessionContext context, Id itemId) {
+
+            return Optional.ofNullable(itemVersion);
+        }
+
+        @Override
+        public Collection<ItemVersion> listPublicVersions(SessionContext context, Id itemId) {
+            return null;
+        }
+
+        @Override
+        public ItemVersion getPublicVersion(SessionContext context, Id itemId, Id versionId) {
+            return null;
+        }
+
+        @Override
+        public Id createVersion(SessionContext context, Id itemId, Id baseVersionId, ItemVersionData itemVersionData) {
+            return null;
+        }
+
+        @Override
+        public void updateVersion(SessionContext context, Id itemId, Id versionId, ItemVersionData itemVersionData) {
+
+        }
+
+        @Override
+        public ItemVersion getVersion(SessionContext context, Id itemId, Id versionId) {
+            return null;
+        }
+
+        @Override
+        public ItemVersionStatus getVersionStatus(SessionContext context, Id itemId, Id versionId) {
+            return null;
+        }
+
+        @Override
+        public ItemVersionConflict getVersionConflict(SessionContext context, Id itemId, Id versionId) {
+            return null;
+        }
+
+        @Override
+        public void tagVersion(SessionContext context, Id itemId, Id versionId, Tag tag) {
+
+        }
+
+        @Override
+        public void resetVersionHistory(SessionContext context, Id itemId, Id versionId, String changeRef) {
+
+        }
+
+        @Override
+        public void publishVersion(SessionContext context, Id itemId, Id versionId, String message) {
+
+        }
+
+        @Override
+        public void syncVersion(SessionContext sessionContext, Id itemId, Id versionId) {
+
+        }
+
+        @Override
+        public void forceSyncVersion(SessionContext context, Id itemId, Id versionId) {
+
+        }
+
+        @Override
+        public void cleanVersion(SessionContext sessionContext, Id itemId, Id versionId) {
+
+        }
+
+        @Override
+        public Optional<ElementInfo> getElementInfo(SessionContext context, ElementContext elementContext,
+                Id elementId) {
+            return Optional.empty();
+        }
+
+        @Override
+        public Optional<Element> getElement(SessionContext context, ElementContext elementContext, String elementId) {
+            return Optional.of(elementMap.get(elementId));
+        }
+
+        @Override
+        public Optional<Element> getElementByName(SessionContext context, ElementContext elementContext,
+                Id parentElementId, String elementName) {
+            //return Optional.empty();
+            ZusammenElement element = new ZusammenElement();
+            Info info = new Info();
+            element.setElementId(Id.ZERO);
+            info.addProperty("name", entity.getName());
+            info.addProperty("description", entity.getDescription());
+            info.addProperty("category", entity.getCategoryList());
+            element.setInfo(info);
+            return Optional.ofNullable(element);
+        }
+
+        @Override
+        public Collection<ElementInfo> listElements(SessionContext context, ElementContext elementContext,
+                Id parentElementId) {
+            return null;
+        }
+
+        @Override
+        public Collection<Element> listElementData(SessionContext context, ElementContext elementContext,
+                Id parentElementId) {
+            return elementMap.values();
+        }
+
+        @Override
+        public Collection<ElementInfo> listElementsByName(SessionContext context, ElementContext elementContext,
+                Id parentElementId, String elementName) {
+
+            return elementMap.values().stream().filter(element -> elementName.equals(element.getInfo().getProperty(
+                    ElementPropertyName.elementType.name()))).map(element -> {
+                ElementInfo elementInfo = new ElementInfo();
+                elementInfo.setId(element.getElementId());
+                elementInfo.setInfo(element.getInfo());
+                return elementInfo;
+            }).collect(Collectors.toList());
+
+        }
+
+        @Override
+        public Optional<ElementInfo> getElementInfoByName(SessionContext context, ElementContext elementContext,
+                Id parentElementId, String elementName) {
+
+
+            return elementMap.values().stream().filter(element -> elementName.equals(element.getInfo().getProperty(
+                    ElementPropertyName.elementType.name()))).map(element -> {
+                ElementInfo elementInfo = new ElementInfo();
+                elementInfo.setId(element.getElementId());
+                elementInfo.setInfo(element.getInfo());
+                return elementInfo;
+            }).findAny();
+
+
+        }
+
+        @Override
+        public Optional<ElementConflict> getElementConflict(SessionContext context, ElementContext elementContext,
+                Id id) {
+            return Optional.empty();
+        }
+
+        @Override
+        public Element saveElement(SessionContext context, ElementContext elementContext, ZusammenElement element,
+                String message) {
+            if (element.getAction().equals(Action.CREATE) || element.getAction().equals(Action.UPDATE)) {
+                element.setElementId(new Id(UUID.randomUUID().toString()));
+            }
+            elementMap.put(element.getElementId().getValue(), element);
+            elementId = element.getElementId().getValue();
+            return element;
+        }
+
+        @Override
+        public void resolveElementConflict(SessionContext context, ElementContext elementContext,
+                ZusammenElement element, Resolution resolution) {
+
+        }
+
+        @Override
+        public void revert(SessionContext sessionContext, Id itemId, Id versionId, Id revisionId) {
+
+        }
+
+        @Override
+        public ItemVersionRevisions listRevisions(SessionContext sessionContext, Id itemId, Id versionId) {
+            return null;
+        }
+
+        @Override
+        public Collection<HealthInfo> checkHealth(SessionContext context) {
+            return null;
+        }
+
+        @Override
+        public String getVersion(SessionContext sessionContext) {
+            return null;
+        }
+
+    }
+
+}
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
index b86b14b9..9d202fce 100644
--- 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
@@ -26,7 +26,7 @@ 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.onap.sdc.workflow.persistence.impl.types.WorkflowElementType;
 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
 
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
index 07a42658..546a3fe6 100644
--- 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
@@ -26,10 +26,10 @@ 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.impl.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.onap.sdc.workflow.persistence.impl.types.WorkflowElementType;
 import org.openecomp.core.zusammen.api.ZusammenAdaptor;
 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
 
@@ -62,7 +62,7 @@ public class ParameterRepositoryTest {
         Info info = new Info();
         info.setName("testInput");
         info.addProperty(ParameterPropertyName.TYPE.name(), ParameterType.FLOAT.name());
-        info.addProperty(ParameterPropertyName.mandatory.name(), true);
+        info.addProperty(ParameterPropertyName.MANDATORY.name(), true);
         element.setInfo(info);
         doReturn(Optional.of(element)).when(zusammenAdaptorMock)
                                       .getElementInfo(any(SessionContext.class), any(ElementContext.class),
@@ -118,14 +118,14 @@ public class ParameterRepositoryTest {
         Info info1 = new Info();
         info1.setName("input1");
         info1.addProperty(ParameterPropertyName.TYPE.name(), "INTEGER");
-        info1.addProperty(ParameterPropertyName.mandatory.name(), true);
+        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);
+        info2.addProperty(ParameterPropertyName.MANDATORY.name(), false);
         parameter2.setInfo(info2);
         Collection<ElementInfo> parameters = Collections.asSet(parameter1, parameter2);
         doReturn(parameters).when(zusammenAdaptorMock)
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
index 4911060a..5c285c3b 100644
--- 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
@@ -38,45 +38,45 @@ public class UniqueValueServiceTest {
     }
 
     @Test
-    public void shouldCallRepositoryInsertIfValueUnique(){
+    public void shouldCallRepositoryInsertIfValueUnique() {
         doReturn(Optional.empty()).when(uniqueValueRepositoryMock).findById(any());
-        uniqueValueService.createUniqueValue(TYPE, new String[]{DUMMY_COMBINATION});
+        uniqueValueService.createUniqueValue(TYPE, DUMMY_COMBINATION);
         verify(uniqueValueRepositoryMock, times(1)).insert(any(UniqueValueEntity.class));
     }
 
     @Test
-    public void shouldNotCheckValueIfNoUniqueCombination(){
-        uniqueValueService.createUniqueValue(TYPE, null);
+    public void shouldNotCheckValueIfNoUniqueCombination() {
+        uniqueValueService.createUniqueValue(TYPE);
         verify(uniqueValueRepositoryMock, never()).findById(any(UniqueValueEntity.class));
     }
 
     @Test(expected = UniqueValueViolationException.class)
-    public void shouldThrowExceptionIfValueIsNotUnique(){
+    public void shouldThrowExceptionIfValueIsNotUnique() {
         doReturn(Optional.of("xxx")).when(uniqueValueRepositoryMock).findById(any());
-        uniqueValueService.createUniqueValue(TYPE, new String[]{DUMMY_COMBINATION});
+        uniqueValueService.createUniqueValue(TYPE, DUMMY_COMBINATION);
     }
 
     @Test
-    public void shouldCallRepositoryDeleteIfValueValid(){
-        uniqueValueService.deleteUniqueValue(TYPE, new String[]{DUMMY_COMBINATION});
+    public void shouldCallRepositoryDeleteIfValueValid() {
+        uniqueValueService.deleteUniqueValue(TYPE, DUMMY_COMBINATION);
         verify(uniqueValueRepositoryMock, times(1)).delete(any(UniqueValueEntity.class));
     }
 
     @Test
-    public void shouldNotCallRepositoryDeleteIfValueNouniqueCombination(){
-        uniqueValueService.deleteUniqueValue(TYPE, new String[]{});
+    public void shouldNotCallRepositoryDeleteIfValueNouniqueCombination() {
+        uniqueValueService.deleteUniqueValue(TYPE);
         verify(uniqueValueRepositoryMock, never()).delete(any(UniqueValueEntity.class));
     }
 
     @Test
-    public void shouldNotUpdateIfNewAndOldValueAreEqualsCaseIgnore(){
+    public void shouldNotUpdateIfNewAndOldValueAreEqualsCaseIgnore() {
         String value = "value";
         uniqueValueService.updateUniqueValue(TYPE, value, value.toUpperCase());
         verify(uniqueValueService, never()).createUniqueValue(anyString(), any());
     }
 
     @Test
-    public void shouldUpdateIfNewAndOldValueAreNotEqualsCaseIgnore(){
+    public void shouldUpdateIfNewAndOldValueAreNotEqualsCaseIgnore() {
         String oldValue = "oldValue";
         String newValue = "newValue";
         uniqueValueService.updateUniqueValue(TYPE, oldValue, newValue);
@@ -87,12 +87,12 @@ public class UniqueValueServiceTest {
     @Test
     public void shouldReturnTrueIfValueExist() {
         doReturn(Optional.of("xxx")).when(uniqueValueRepositoryMock).findById(any());
-        assertTrue(uniqueValueService.isUniqueValueOccupied(TYPE, new String[]{DUMMY_COMBINATION}));
+        assertTrue(uniqueValueService.isUniqueValueOccupied(TYPE, DUMMY_COMBINATION));
     }
 
     @Test
     public void shouldReturnFalseIfValueNotExist() {
         doReturn(Optional.empty()).when(uniqueValueRepositoryMock).findById(any());
-        assertFalse(uniqueValueService.isUniqueValueOccupied(TYPE, new String[]{DUMMY_COMBINATION}));
+        assertFalse(uniqueValueService.isUniqueValueOccupied(TYPE, DUMMY_COMBINATION));
     }
 }
diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/ActivitySpecManagerImplTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/ActivitySpecManagerImplTest.java
new file mode 100644
index 00000000..719531bf
--- /dev/null
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/services/impl/ActivitySpecManagerImplTest.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright © 2016-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.sdc.workflow.services.impl;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+import static org.onap.sdc.workflow.services.ActivitySpecConstant.ACTIVITY_SPEC_NOT_FOUND;
+import static org.onap.sdc.workflow.services.ActivitySpecConstant.VERSION_ID_DEFAULT_VALUE;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+import org.onap.sdc.workflow.api.types.activityspec.ActivitySpecAction;
+import org.onap.sdc.workflow.persistence.ActivitySpecRepository;
+import org.onap.sdc.workflow.persistence.types.ActivitySpecEntity;
+import org.onap.sdc.workflow.persistence.types.ActivitySpecParameter;
+import org.onap.sdc.workflow.services.UniqueValueService;
+import org.onap.sdc.workflow.services.exceptions.EntityNotFoundException;
+import org.onap.sdc.workflow.services.exceptions.VersionStatusModificationException;
+import org.onap.sdc.workflow.services.impl.mappers.ActivitySpecMapper;
+import org.openecomp.sdc.common.errors.SdcRuntimeException;
+import org.openecomp.sdc.versioning.ItemManager;
+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.Item;
+
+public class ActivitySpecManagerImplTest {
+
+    private static final String STRING_TYPE = "String";
+    private static final String TEST_ERROR_MSG = "Test Error";
+    private static final String ID = "ID1";
+    private Version version01 = new Version("12345");
+    private ActivitySpecEntity input;
+
+    @Spy
+    @InjectMocks
+    private ActivitySpecManagerImpl activitySpecManager;
+    @Mock
+    private ItemManager itemManagerMock;
+    @Mock
+    private VersioningManager versionManagerMock;
+    @Mock
+    private ActivitySpecRepository activitySpecRepositoryMock;
+    @Mock
+    private UniqueValueService uniqueValueServiceMock;
+    @Mock
+    private ActivitySpecMapper activitySpecMapperMock;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @After
+    public void tearDown() {
+        activitySpecManager = null;
+    }
+
+    @Test
+    public void testCreate() {
+        ActivitySpecEntity activitySpecToCreate = new ActivitySpecEntity();
+        activitySpecToCreate.setName("startserver");
+        activitySpecToCreate.setDescription("start the server");
+        activitySpecToCreate.setVersion(version01);
+
+        List<String> categoryList = new ArrayList<>();
+        categoryList.add("category1");
+        categoryList.add("category2");
+        activitySpecToCreate.setCategoryList(categoryList);
+
+        ActivitySpecParameter inputParams = new ActivitySpecParameter("dbhost", STRING_TYPE, null);
+        inputParams.setValue("localhost");
+        ActivitySpecParameter inputParams1 = new ActivitySpecParameter("dbname", STRING_TYPE, null);
+        inputParams.setValue("prod");
+        List<ActivitySpecParameter> inputs = new ArrayList<>();
+        inputs.add(inputParams);
+        inputs.add(inputParams1);
+        activitySpecToCreate.setInputs(inputs);
+
+        ActivitySpecParameter outputParams = new ActivitySpecParameter("status", STRING_TYPE, null);
+        outputParams.setValue("started");
+        List<ActivitySpecParameter> outputs = new ArrayList<>();
+        outputs.add(outputParams);
+        activitySpecToCreate.setOutputs(outputs);
+
+        activitySpecToCreate.setId("ID1");
+        activitySpecToCreate.setVersion(version01);
+
+        Item mappedItem = new Item();
+        doReturn(mappedItem).when(activitySpecMapperMock).activitySpecToItem(activitySpecToCreate);
+        doReturn(new Item()).when(itemManagerMock).create(mappedItem);
+
+        ActivitySpecEntity activitySpec = activitySpecManager.createActivitySpec(activitySpecToCreate);
+
+        Assert.assertNotNull(activitySpec);
+        activitySpec.setId("ID1");
+        activitySpec.setStatus(VersionStatus.Draft.name());
+        assertActivitySpecEquals(activitySpec, activitySpecToCreate);
+    }
+
+    private void assertActivitySpecEquals(ActivitySpecEntity actual, ActivitySpecEntity expected) {
+        Assert.assertEquals(actual.getId(), expected.getId());
+        Assert.assertEquals(actual.getName(), expected.getName());
+        Assert.assertEquals(actual.getDescription(), expected.getDescription());
+        Assert.assertEquals(actual.getCategoryList(), expected.getCategoryList());
+        Assert.assertEquals(actual.getInputs(), expected.getInputs());
+        Assert.assertEquals(actual.getOutputs(), expected.getOutputs());
+    }
+
+    @Test
+    public void testList() {
+        Item item = new Item();
+        item.setId(ID);
+        doReturn(Collections.singletonList(item)).when(itemManagerMock).list(any());
+        doReturn(new ActivitySpecEntity(ID, null)).when(activitySpecMapperMock).itemToActivitySpec(item);
+
+        final Collection<ActivitySpecEntity> activitySpecs = activitySpecManager.list("Certified");
+        Assert.assertEquals(1, activitySpecs.size());
+        Assert.assertEquals(ID, activitySpecs.iterator().next().getId());
+    }
+
+    @Test
+    public void testListInvalidFilter() {
+        final Collection<ActivitySpecEntity> activitySpecs = activitySpecManager.list("invalid_status");
+        Assert.assertEquals(0, activitySpecs.size());
+    }
+
+    @Test
+    public void testListNoFilter() {
+        final Collection<ActivitySpecEntity> activitySpecs = activitySpecManager.list(null);
+        Assert.assertEquals(0, activitySpecs.size());
+    }
+
+    @Test
+    public void testGet() {
+        input = new ActivitySpecEntity();
+        input.setId(ID);
+        input.setVersion(version01);
+
+        mockListVersions();
+        doReturn(input).when(activitySpecRepositoryMock).get(any());
+        version01.setStatus(VersionStatus.Draft);
+        doReturn(version01).when(versionManagerMock).get(any(), any());
+        ActivitySpecEntity retrieved = activitySpecManager.get(input);
+        assertActivitySpecEquals(retrieved, input);
+        Assert.assertEquals(retrieved.getStatus(), VersionStatus.Draft.name());
+
+
+        input.setVersion(new Version(VERSION_ID_DEFAULT_VALUE));
+        retrieved = activitySpecManager.get(input);
+        assertActivitySpecEquals(retrieved, input);
+        Assert.assertEquals(retrieved.getStatus(), VersionStatus.Draft.name());
+    }
+
+    private void mockListVersions() {
+        doReturn(Collections.singletonList(version01)).when(versionManagerMock).list(any());
+    }
+
+    @Test
+    public void testGetActivitySpecDaoFail() {
+        input = new ActivitySpecEntity();
+        input.setId(ID);
+        input.setVersion(version01);
+        mockListVersions();
+        doReturn(input).when(activitySpecRepositoryMock).get(any());
+        Mockito.doThrow(new SdcRuntimeException(TEST_ERROR_MSG)).when(activitySpecRepositoryMock).get(any());
+        try {
+            activitySpecManager.get(input);
+            Assert.fail();
+        } catch (EntityNotFoundException exception) {
+            Assert.assertEquals(ACTIVITY_SPEC_NOT_FOUND, exception.getMessage());
+        }
+    }
+
+    @Test
+    public void testListVersionFail() {
+        input = new ActivitySpecEntity();
+        input.setId(ID);
+        input.setVersion(version01);
+        input.getVersion().setId(VERSION_ID_DEFAULT_VALUE);
+        Mockito.doThrow(new SdcRuntimeException(TEST_ERROR_MSG)).when(versionManagerMock).list(any());
+        try {
+            activitySpecManager.get(input);
+            Assert.fail();
+        } catch (EntityNotFoundException exception) {
+            Assert.assertEquals(ACTIVITY_SPEC_NOT_FOUND, exception.getMessage());
+        }
+    }
+
+    @Test(expected = VersionStatusModificationException.class)
+    public void testInvalidDeprecate() {
+        Version version = new Version(version01.getId());
+        version.setStatus(VersionStatus.Draft);
+        doReturn(version).when(versionManagerMock).get(ID, version01);
+        activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.DEPRECATE);
+    }
+
+    @Test(expected = VersionStatusModificationException.class)
+    public void testInvalidDelete() {
+        mockCertifiedVersion();
+        activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.DELETE);
+    }
+
+    private void mockCertifiedVersion() {
+        Version version = new Version(version01.getId());
+        version.setStatus(VersionStatus.Certified);
+        doReturn(version).when(versionManagerMock).get(ID, version01);
+    }
+
+    @Test(expected = VersionStatusModificationException.class)
+    public void testInvalidCertify() {
+        mockCertifiedVersion();
+        activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.CERTIFY);
+    }
+
+    @Test
+    public void testCertify() {
+        Version retrievedVersion = new Version(version01.getId());
+        retrievedVersion.setStatus(VersionStatus.Draft);
+        doReturn(Collections.singletonList(retrievedVersion)).when(versionManagerMock).list(any());
+        doReturn(retrievedVersion).when(versionManagerMock).get(any(), any());
+
+        activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.CERTIFY);
+
+        verify(versionManagerMock).updateVersion(ID, retrievedVersion);
+        verify(itemManagerMock).updateVersionStatus(ID, VersionStatus.Certified, VersionStatus.Draft);
+        verify(versionManagerMock).publish(ID, retrievedVersion, "actionOnActivitySpec :CERTIFY");
+    }
+
+    @Test
+    public void testGetVersionFailOnStatusChangeAction() {
+        mockListVersions();
+        Mockito.doThrow(new SdcRuntimeException(TEST_ERROR_MSG)).when(versionManagerMock).get(any(), any());
+        try {
+            activitySpecManager.actOnAction(new ActivitySpecEntity(ID, version01), ActivitySpecAction.CERTIFY);
+            Assert.fail();
+        } catch (EntityNotFoundException exception) {
+            Assert.assertEquals(ACTIVITY_SPEC_NOT_FOUND, exception.getMessage());
+        }
+    }
+
+    @Test
+    public void testDeprecate() {
+        version01.setStatus(VersionStatus.Certified);
+        Version retrivedVersion = new Version("12");
+        retrivedVersion.setStatus(VersionStatus.Certified);
+        mockListVersions();
+        doReturn(retrivedVersion).when(versionManagerMock).get(any(), any());
+        activitySpecManager.actOnAction(new ActivitySpecEntity(ID, new Version(VERSION_ID_DEFAULT_VALUE)), ActivitySpecAction.DEPRECATE);
+
+        verify(versionManagerMock).updateVersion(ID, retrivedVersion);
+        verify(itemManagerMock).updateVersionStatus(ID, VersionStatus.Deprecated, VersionStatus.Certified);
+        verify(versionManagerMock).publish(any(), any(), any());
+    }
+
+    @Test
+    public void testDelete() {
+        ActivitySpecEntity activitySpec = new ActivitySpecEntity();
+        version01.setStatus(VersionStatus.Deprecated);
+        activitySpec.setName("stopServer");
+        activitySpec.setVersion(version01);
+
+        Version retrivedVersion = new Version("12");
+        retrivedVersion.setStatus(VersionStatus.Deprecated);
+
+        mockListVersions();
+        doReturn(retrivedVersion).when(versionManagerMock).get(any(), any());
+        doReturn(activitySpec).when(activitySpecRepositoryMock).get(any());
+        activitySpecManager.actOnAction(new ActivitySpecEntity(ID, new Version(VERSION_ID_DEFAULT_VALUE)), ActivitySpecAction.DELETE);
+
+        verify(versionManagerMock).updateVersion(ID, version01);
+        verify(itemManagerMock).updateVersionStatus(ID, VersionStatus.Deleted, VersionStatus.Deprecated);
+        verify(versionManagerMock).publish(any(), any(), any());
+    }
+}
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
index de17a049..2b93075b 100644
--- 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
@@ -25,8 +25,8 @@ 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.types.Workflow;
+import org.onap.sdc.workflow.services.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;
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
index be6fe04e..9640fa1b 100644
--- 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
@@ -7,15 +7,13 @@ 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 static org.onap.sdc.workflow.services.types.WorkflowVersionState.CERTIFIED;
+import static org.onap.sdc.workflow.services.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;
@@ -32,8 +30,8 @@ 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.types.WorkflowVersion;
+import org.onap.sdc.workflow.services.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;
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
index d9790355..3ee3c07c 100644
--- 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
@@ -5,8 +5,8 @@ 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.onap.sdc.workflow.services.types.WorkflowVersion;
+import org.onap.sdc.workflow.services.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;
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
index 070c433e..b69b0f7b 100644
--- 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
@@ -4,7 +4,7 @@ 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.onap.sdc.workflow.services.types.WorkflowVersionState;
 import org.openecomp.sdc.versioning.dao.types.VersionStatus;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.ComponentScan;
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
index 55802cc0..d6e16d57 100644
--- 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
@@ -8,7 +8,7 @@ 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.onap.sdc.workflow.services.types.Workflow;
 import org.openecomp.sdc.versioning.types.Item;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.ComponentScan;