[Feature][jsonsplit]add ProcessTaskRelationServiceImplTest/TaskDefinitionServiceImplTest (#4949)

* Modify Project and ProjectUser Mapper

* Modify Project and ProjectUser Mapper

* project_code is bigint(20)

* modify ERROR name

* modify saveProcessDefine, remove the duplicate code with createTaskAndRelation

* modify import/export processdefinition, add genProcessData

* fix ut and bug

* code style

* repalce project_id with code

* conflicts solve

* conflicts solve

* conflicts solve

* bugfix

* modify listResources mothod and remove getResourceIds mothod

* 1

* conflicts solve

* modify listResources mothod and remove getResourceIds mothod

* modify listResources mothod and remove getResourceIds mothod

* replace processDefinitionVersion with processDefinitionLog

* codestyle

* codestyle

* add ProcessTaskRelationServiceImplTest/TaskDefinitionServiceImplTest

* conflicts solve

* conflicts solve

* conflicts solve

* add ProcessTaskRelationServiceImplTest/TaskDefinitionServiceImplTest

* codestyle

dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessInstanceServiceImpl.java

@@ -753,4 +753,4 @@ public class ProcessInstanceServiceImpl extends BaseServiceImpl implements Proce
         return processInstanceMapper.queryByProcessDefineId(processDefinitionId, size);
     }
 
-}
+}

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/DataAnalysisServiceTest.java

@@ -131,6 +131,8 @@ public class DataAnalysisServiceTest {
         //SUCCESS
         Mockito.when(taskInstanceMapper.countTaskInstanceStateByUser(DateUtils.getScheduleDate(startDate),
                 DateUtils.getScheduleDate(endDate), new Long[]{1L})).thenReturn(getTaskInstanceStateCounts());
+        Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
+        Mockito.when(projectService.hasProjectAndPerm(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
 
         result = dataAnalysisService.countTaskStateByProject(user, 1, startDate, endDate);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
@@ -215,15 +217,18 @@ public class DataAnalysisServiceTest {
         Assert.assertTrue(result.isEmpty());
 
         //SUCCESS
+        Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
         Mockito.when(processInstanceMapper.countInstanceStateByUser(DateUtils.getScheduleDate(startDate),
                 DateUtils.getScheduleDate(endDate), new Long[]{1L})).thenReturn(getTaskInstanceStateCounts());
+        Mockito.when(projectService.hasProjectAndPerm(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
+
         result = dataAnalysisService.countProcessInstanceStateByProject(user, 1, startDate, endDate);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
     }
 
     @Test
     public void testCountDefinitionByUser() {
-
+        Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
         Map<String, Object> result = dataAnalysisService.countDefinitionByUser(user, 1);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
     }
@@ -245,14 +250,12 @@ public class DataAnalysisServiceTest {
 
         Mockito.when(errorCommandMapper.countCommandState(DateUtils.getScheduleDate(startDate),
                 DateUtils.getScheduleDate(endDate), new Long[]{1L})).thenReturn(commandCounts);
+        Mockito.when(projectMapper.selectById(Mockito.any())).thenReturn(getProject("test"));
+        Mockito.when(projectService.hasProjectAndPerm(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
 
         result = dataAnalysisService.countCommandState(user, 1, startDate, endDate);
         Assert.assertEquals(Status.SUCCESS, result.get(Constants.STATUS));
 
-        // when project check fail then return nothing
-        Map<String, Object> result1 = dataAnalysisService.countCommandState(user, 2, null, null);
-        Assert.assertTrue(result1.isEmpty());
-
         // when all date in illegal format then return error message
         String startDate2 = "illegalDateString";
         String endDate2 = "illegalDateString";
@@ -325,4 +328,18 @@ public class DataAnalysisServiceTest {
         return taskInstanceStateCounts;
     }
 
+    /**
+     * get mock Project
+     *
+     * @param projectName projectName
+     * @return Project
+     */
+    private Project getProject(String projectName) {
+        Project project = new Project();
+        project.setCode(11L);
+        project.setId(1);
+        project.setName(projectName);
+        project.setUserId(1);
+        return project;
+    }
 }

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionServiceTest.java

@@ -605,7 +605,6 @@ public class ProcessDefinitionServiceTest {
         schedules.add(schedule);
         Mockito.when(scheduleMapper.queryByProcessDefinitionId(46)).thenReturn(schedules);
         Mockito.when(processDefineMapper.deleteById(46)).thenReturn(0);
-        Mockito.when(processTaskRelationMapper.deleteByCode(null, null)).thenReturn(0);
         Map<String, Object> deleteFail = processDefinitionService.deleteProcessDefinitionById(loginUser,
                 "project_test1", 46);
         Assert.assertEquals(Status.DELETE_PROCESS_DEFINE_BY_ID_ERROR, deleteFail.get(Constants.STATUS));
@@ -789,8 +788,9 @@ public class ProcessDefinitionServiceTest {
         processDefinition.setProcessDefinitionJson(SHELL_JSON);
         List<ProcessDefinition> processDefinitionList = new ArrayList<>();
         processDefinitionList.add(processDefinition);
-        Project project = projectMapper.selectById(projectId);
+        Project test = getProject("test");
-        Mockito.when(processDefineMapper.queryAllDefinitionList(project.getCode())).thenReturn(processDefinitionList);
+        Mockito.when(projectMapper.selectById(projectId)).thenReturn(test);
+        Mockito.when(processDefineMapper.queryAllDefinitionList(test.getCode())).thenReturn(processDefinitionList);
         Map<String, Object> successRes = processDefinitionService.queryProcessDefinitionAllByProjectId(projectId);
         Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS));
     }
@@ -1163,81 +1163,6 @@ public class ProcessDefinitionServiceTest {
 
     }
 
-    @Test
-    public void testGetResourceIds() throws Exception {
-        // set up
-        Method testMethod = ReflectionUtils.findMethod(ProcessDefinitionServiceImpl.class, "getResourceIds", ProcessData.class);
-        assertThat(testMethod).isNotNull();
-        testMethod.setAccessible(true);
-
-        // when processData has empty task, then return empty string
-        ProcessData input1 = new ProcessData();
-        input1.setTasks(Collections.emptyList());
-        String output1 = (String) testMethod.invoke(processDefinitionService, input1);
-        assertThat(output1).isEmpty();
-
-        // when task is null, then return empty string
-        ProcessData input2 = new ProcessData();
-        input2.setTasks(null);
-        String output2 = (String) testMethod.invoke(processDefinitionService, input2);
-        assertThat(output2).isEmpty();
-
-        // when task type is incorrect mapping, then return empty string
-        ProcessData input3 = new ProcessData();
-        TaskNode taskNode3 = new TaskNode();
-        taskNode3.setType("notExistType");
-        input3.setTasks(Collections.singletonList(taskNode3));
-        String output3 = (String) testMethod.invoke(processDefinitionService, input3);
-        assertThat(output3).isEmpty();
-
-        // when task parameter list is null, then return empty string
-        ProcessData input4 = new ProcessData();
-        TaskNode taskNode4 = new TaskNode();
-        taskNode4.setType("SHELL");
-        taskNode4.setParams(null);
-        input4.setTasks(Collections.singletonList(taskNode4));
-        String output4 = (String) testMethod.invoke(processDefinitionService, input4);
-        assertThat(output4).isEmpty();
-
-        // when resource id list is 0 1, then return 0,1
-        ProcessData input5 = new ProcessData();
-        TaskNode taskNode5 = new TaskNode();
-        taskNode5.setType("SHELL");
-        ShellParameters shellParameters5 = new ShellParameters();
-        ResourceInfo resourceInfo5A = new ResourceInfo();
-        resourceInfo5A.setId(1);
-        ResourceInfo resourceInfo5B = new ResourceInfo();
-        resourceInfo5B.setId(2);
-        shellParameters5.setResourceList(Arrays.asList(resourceInfo5A, resourceInfo5B));
-        taskNode5.setParams(JSONUtils.toJsonString(shellParameters5));
-        input5.setTasks(Collections.singletonList(taskNode5));
-        String output5 = (String) testMethod.invoke(processDefinitionService, input5);
-        assertThat(output5.split(",")).hasSize(2)
-                .containsExactlyInAnyOrder("1", "2");
-
-        // when resource id list is 0 1 1 2, then return 0,1,2
-        ProcessData input6 = new ProcessData();
-        TaskNode taskNode6 = new TaskNode();
-        taskNode6.setType("SHELL");
-        ShellParameters shellParameters6 = new ShellParameters();
-        ResourceInfo resourceInfo6A = new ResourceInfo();
-        resourceInfo6A.setId(3);
-        ResourceInfo resourceInfo6B = new ResourceInfo();
-        resourceInfo6B.setId(1);
-        ResourceInfo resourceInfo6C = new ResourceInfo();
-        resourceInfo6C.setId(1);
-        ResourceInfo resourceInfo6D = new ResourceInfo();
-        resourceInfo6D.setId(2);
-        shellParameters6.setResourceList(Arrays.asList(resourceInfo6A, resourceInfo6B, resourceInfo6C, resourceInfo6D));
-        taskNode6.setParams(JSONUtils.toJsonString(shellParameters6));
-        input6.setTasks(Collections.singletonList(taskNode6));
-
-        String output6 = (String) testMethod.invoke(processDefinitionService, input6);
-
-        assertThat(output6.split(",")).hasSize(3)
-                .containsExactlyInAnyOrder("3", "1", "2");
-    }
-
     /**
      * get mock datasource
      *

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessInstanceServiceTest.java

@@ -32,14 +32,19 @@ import org.apache.dolphinscheduler.common.enums.ExecutionStatus;
 import org.apache.dolphinscheduler.common.enums.Flag;
 import org.apache.dolphinscheduler.common.enums.TaskType;
 import org.apache.dolphinscheduler.common.enums.UserType;
+import org.apache.dolphinscheduler.common.graph.DAG;
+import org.apache.dolphinscheduler.common.model.TaskNode;
+import org.apache.dolphinscheduler.common.model.TaskNodeRelation;
 import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.dao.entity.ProcessDefinition;
+import org.apache.dolphinscheduler.dao.entity.ProcessDefinitionLog;
 import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
 import org.apache.dolphinscheduler.dao.entity.Project;
 import org.apache.dolphinscheduler.dao.entity.TaskInstance;
 import org.apache.dolphinscheduler.dao.entity.Tenant;
 import org.apache.dolphinscheduler.dao.entity.User;
 import org.apache.dolphinscheduler.dao.entity.WorkerGroup;
+import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionLogMapper;
 import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionMapper;
 import org.apache.dolphinscheduler.dao.mapper.ProcessInstanceMapper;
 import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
@@ -86,6 +91,9 @@ public class ProcessInstanceServiceTest {
     @Mock
     ProcessInstanceMapper processInstanceMapper;
 
+    @Mock
+    ProcessDefinitionLogMapper processDefinitionLogMapper;
+
     @Mock
     ProcessDefinitionMapper processDefineMapper;
 
@@ -384,12 +392,20 @@ public class ProcessInstanceServiceTest {
         when(processService.getTenantForProcess(Mockito.anyInt(), Mockito.anyInt())).thenReturn(tenant);
         when(processService.updateProcessInstance(processInstance)).thenReturn(1);
         when(processDefinitionService.checkProcessNodeList(Mockito.any(), eq(shellJson))).thenReturn(result);
+        when(processService.findProcessDefinition(processInstance.getProcessDefinitionCode(),
+                processInstance.getProcessDefinitionVersion())).thenReturn(processDefinition);
+
         Map<String, Object> processInstanceFinishRes = processInstanceService.updateProcessInstance(loginUser, projectName, 1,
                 shellJson, "2020-02-21 00:00:00", true, Flag.YES, "", "");
         Assert.assertEquals(Status.UPDATE_PROCESS_INSTANCE_ERROR, processInstanceFinishRes.get(Constants.STATUS));
 
         //success
         when(processDefineMapper.updateById(processDefinition)).thenReturn(1);
+        when(processService.saveProcessDefinition(Mockito.any(), Mockito.any(),
+                Mockito.anyString(), Mockito.anyString(), Mockito.anyString(),
+                Mockito.anyString(), Mockito.any(), Mockito.any())).thenReturn(1);
+        putMsg(result, Status.SUCCESS, projectName);
+
         Map<String, Object> successRes = processInstanceService.updateProcessInstance(loginUser, projectName, 1,
                 shellJson, "2020-02-21 00:00:00", true, Flag.YES, "", "");
         Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS));
@@ -477,7 +493,20 @@ public class ProcessInstanceServiceTest {
         taskInstance.setState(ExecutionStatus.RUNNING_EXECUTION);
         taskInstance.setStartTime(new Date());
         when(processInstanceMapper.queryDetailById(1)).thenReturn(processInstance);
+        when(processDefinitionLogMapper.queryByDefinitionCodeAndVersion(
+                processInstance.getProcessDefinitionCode(),
+                processInstance.getProcessDefinitionVersion()
+        )).thenReturn(new ProcessDefinitionLog());
+        when(processInstanceMapper.queryDetailById(1)).thenReturn(processInstance);
         when(taskInstanceMapper.queryByInstanceIdAndName(Mockito.anyInt(), Mockito.any())).thenReturn(taskInstance);
+        DAG<String, TaskNode, TaskNodeRelation> graph = new DAG<>();
+        for (int i = 1; i <= 7; ++i) {
+            graph.addNode(i + "", new TaskNode());
+        }
+
+        when(processService.genDagGraph(Mockito.any(ProcessDefinition.class)))
+                .thenReturn(graph);
+
         Map<String, Object> successRes = processInstanceService.viewGantt(1);
         Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS));
     }
@@ -530,9 +559,11 @@ public class ProcessInstanceServiceTest {
      */
     private ProcessDefinition getProcessDefinition() {
         ProcessDefinition processDefinition = new ProcessDefinition();
+        processDefinition.setCode(46L);
         processDefinition.setId(46);
         processDefinition.setName("test_pdf");
         processDefinition.setProjectId(2);
+        processDefinition.setProjectCode(2L);
         processDefinition.setTenantId(1);
         processDefinition.setDescription("");
         return processDefinition;

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationServiceImplTest.java

@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.dolphinscheduler.api.service;
+
+import org.apache.dolphinscheduler.api.enums.Status;
+import org.apache.dolphinscheduler.api.service.impl.ProcessTaskRelationServiceImpl;
+import org.apache.dolphinscheduler.api.service.impl.ProjectServiceImpl;
+import org.apache.dolphinscheduler.common.Constants;
+import org.apache.dolphinscheduler.common.enums.UserType;
+import org.apache.dolphinscheduler.dao.entity.Project;
+import org.apache.dolphinscheduler.dao.entity.User;
+import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionMapper;
+import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationMapper;
+import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
+
+import java.text.MessageFormat;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ProcessTaskRelationServiceImplTest {
+    @InjectMocks
+    private ProcessTaskRelationServiceImpl processTaskRelationService;
+
+    @Mock
+    private ProcessDefinitionMapper processDefineMapper;
+
+    @Mock
+    private ProcessTaskRelationMapper processTaskRelationMapper;
+
+    @Mock
+    private ProjectMapper projectMapper;
+
+    @Mock
+    private ProjectServiceImpl projectService;
+
+    @Test
+    public void queryProcessTaskRelationTest() {
+        String projectName = "project_test1";
+
+        Project project = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project);
+
+        User loginUser = new User();
+        loginUser.setId(-1);
+        loginUser.setUserType(UserType.GENERAL_USER);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, projectName);
+
+        //project check auth fail
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        Map<String, Object> relation = processTaskRelationService
+                .queryProcessTaskRelation(loginUser, projectName, 11L);
+
+        Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS));
+    }
+
+    private void putMsg(Map<String, Object> result, Status status, Object... statusParams) {
+        result.put(Constants.STATUS, status);
+        if (statusParams != null && statusParams.length > 0) {
+            result.put(Constants.MSG, MessageFormat.format(status.getMsg(), statusParams));
+        } else {
+            result.put(Constants.MSG, status.getMsg());
+        }
+    }
+
+    /**
+     * get mock Project
+     *
+     * @param projectName projectName
+     * @return Project
+     */
+    private Project getProject(String projectName) {
+        Project project = new Project();
+        project.setCode(11L);
+        project.setId(1);
+        project.setName(projectName);
+        project.setUserId(1);
+        return project;
+    }
+
+}

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProjectServiceTest.java

@@ -348,6 +348,7 @@ public class ProjectServiceTest {
 
     private Project getProject() {
         Project project = new Project();
+        project.setCode(1L);
         project.setId(1);
         project.setName(projectName);
         project.setUserId(1);

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskDefinitionServiceImplTest.java

@@ -0,0 +1,298 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.apache.dolphinscheduler.api.service;
+
+import org.apache.dolphinscheduler.api.enums.Status;
+import org.apache.dolphinscheduler.api.service.impl.ProjectServiceImpl;
+import org.apache.dolphinscheduler.api.service.impl.TaskDefinitionServiceImpl;
+import org.apache.dolphinscheduler.common.Constants;
+import org.apache.dolphinscheduler.common.enums.UserType;
+import org.apache.dolphinscheduler.common.model.TaskNode;
+import org.apache.dolphinscheduler.common.utils.JSONUtils;
+import org.apache.dolphinscheduler.dao.entity.Project;
+import org.apache.dolphinscheduler.dao.entity.TaskDefinition;
+import org.apache.dolphinscheduler.dao.entity.TaskDefinitionLog;
+import org.apache.dolphinscheduler.dao.entity.User;
+import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionMapper;
+import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationMapper;
+import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
+import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionLogMapper;
+import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionMapper;
+import org.apache.dolphinscheduler.service.process.ProcessService;
+
+import java.text.MessageFormat;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TaskDefinitionServiceImplTest {
+
+    String taskDefinitionJson = "{\n"
+            + "    \"type\": \"SQL\",\n"
+            + "    \"id\": \"tasks-27297\",\n"
+            + "    \"name\": \"SQL\",\n"
+            + "    \"params\": {\n"
+            + "        \"type\": \"MYSQL\",\n"
+            + "        \"datasource\": 1,\n"
+            + "        \"sql\": \"select * from test\",\n"
+            + "        \"udfs\": \"\",\n"
+            + "        \"sqlType\": \"1\",\n"
+            + "        \"title\": \"\",\n"
+            + "        \"receivers\": \"\",\n"
+            + "        \"receiversCc\": \"\",\n"
+            + "        \"showType\": \"TABLE\",\n"
+            + "        \"localParams\": [\n"
+            + "            \n"
+            + "        ],\n"
+            + "        \"connParams\": \"\",\n"
+            + "        \"preStatements\": [\n"
+            + "            \n"
+            + "        ],\n"
+            + "        \"postStatements\": [\n"
+            + "            \n"
+            + "        ]\n"
+            + "    },\n"
+            + "    \"description\": \"\",\n"
+            + "    \"runFlag\": \"NORMAL\",\n"
+            + "    \"dependence\": {\n"
+            + "        \n"
+            + "    },\n"
+            + "    \"maxRetryTimes\": \"0\",\n"
+            + "    \"retryInterval\": \"1\",\n"
+            + "    \"timeout\": {\n"
+            + "        \"strategy\": \"\",\n"
+            + "        \"enable\": false\n"
+            + "    },\n"
+            + "    \"taskInstancePriority\": \"MEDIUM\",\n"
+            + "    \"workerGroupId\": -1,\n"
+            + "    \"preTasks\": [\n"
+            + "        \"dependent\"\n"
+            + "    ]\n"
+            + "}\n";
+
+    @InjectMocks
+    private TaskDefinitionServiceImpl taskDefinitionService;
+
+    @Mock
+    private TaskDefinitionMapper taskDefinitionMapper;
+
+    @Mock
+    private TaskDefinitionLogMapper taskDefinitionLogMapper;
+
+    @Mock
+    private ProcessDefinitionMapper processDefineMapper;
+
+    @Mock
+    private ProcessTaskRelationMapper processTaskRelationMapper;
+
+    @Mock
+    private ProjectMapper projectMapper;
+
+    @Mock
+    private ProjectServiceImpl projectService;
+
+    @Mock
+    private ProcessService processService;
+
+    @Test
+    public void createTaskDefinition() {
+        String projectName = "project_test1";
+
+        Project project = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project);
+
+        User loginUser = new User();
+        loginUser.setId(-1);
+        loginUser.setUserType(UserType.GENERAL_USER);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, projectName);
+
+        //project check auth fail
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        TaskNode taskNode = JSONUtils.parseObject(taskDefinitionJson, TaskNode.class);
+
+        Mockito.when(processService.saveTaskDefinition(Mockito.eq(loginUser)
+                , Mockito.eq(project.getCode())
+                , Mockito.eq(taskNode)
+                , Mockito.any(TaskDefinition.class)))
+                .thenReturn(1);
+
+        Map<String, Object> relation = taskDefinitionService
+                .createTaskDefinition(loginUser, projectName, taskDefinitionJson);
+
+        Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS));
+
+    }
+
+    @Test
+    public void queryTaskDefinitionByName() {
+        String projectName = "project_test1";
+        String taskName = "task";
+        Project project = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project);
+
+        User loginUser = new User();
+        loginUser.setId(-1);
+        loginUser.setUserType(UserType.GENERAL_USER);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, projectName);
+
+        //project check auth fail
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        TaskNode taskNode = JSONUtils.parseObject(taskDefinitionJson, TaskNode.class);
+
+        Mockito.when(taskDefinitionMapper.queryByDefinitionName(project.getCode(), taskName))
+                .thenReturn(new TaskDefinition());
+
+        Map<String, Object> relation = taskDefinitionService
+                .queryTaskDefinitionByName(loginUser, projectName, taskName);
+
+        Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS));
+    }
+
+    @Test
+    public void deleteTaskDefinitionByCode() {
+        String projectName = "project_test1";
+
+        Project project = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project);
+
+        User loginUser = new User();
+        loginUser.setId(-1);
+        loginUser.setUserType(UserType.GENERAL_USER);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, projectName);
+
+        //project check auth fail
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        TaskNode taskNode = JSONUtils.parseObject(taskDefinitionJson, TaskNode.class);
+
+        Mockito.when(taskDefinitionMapper.deleteByCode(Mockito.anyLong()))
+                .thenReturn(1);
+
+        Map<String, Object> relation = taskDefinitionService
+                .deleteTaskDefinitionByCode(loginUser, projectName, 11L);
+
+        Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS));
+
+    }
+
+    @Test
+    public void updateTaskDefinition() {
+        String projectName = "project_test1";
+
+        Project project = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project);
+
+        User loginUser = new User();
+        loginUser.setId(-1);
+        loginUser.setUserType(UserType.GENERAL_USER);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, projectName);
+
+        //project check auth fail
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        TaskNode taskNode = JSONUtils.parseObject(taskDefinitionJson, TaskNode.class);
+
+        Mockito.when(processService.updateTaskDefinition(Mockito.eq(loginUser)
+                , Mockito.eq(project.getCode())
+                , Mockito.eq(taskNode)
+                , Mockito.any(TaskDefinition.class)))
+                .thenReturn(1);
+
+        Mockito.when(taskDefinitionMapper.queryByDefinitionCode(11L))
+                .thenReturn(new TaskDefinition());
+
+        Map<String, Object> relation = taskDefinitionService
+                .updateTaskDefinition(loginUser, projectName, 11L, taskDefinitionJson);
+
+        Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS));
+    }
+
+    @Test
+    public void switchVersion() {
+        String projectName = "project_test1";
+        int version = 1;
+        Long taskCode = 11L;
+        Project project = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project);
+
+        User loginUser = new User();
+        loginUser.setId(-1);
+        loginUser.setUserType(UserType.GENERAL_USER);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.SUCCESS, projectName);
+
+        //project check auth fail
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        TaskNode taskNode = JSONUtils.parseObject(taskDefinitionJson, TaskNode.class);
+
+        Mockito.when(taskDefinitionLogMapper.queryByDefinitionCodeAndVersion(taskCode, version))
+                .thenReturn(new TaskDefinitionLog());
+
+        Mockito.when(taskDefinitionMapper.queryByDefinitionCode(taskCode))
+                .thenReturn(new TaskDefinition());
+        
+        Map<String, Object> relation = taskDefinitionService
+                .switchVersion(loginUser, projectName, taskCode, version);
+
+        Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS));
+    }
+
+    private void putMsg(Map<String, Object> result, Status status, Object... statusParams) {
+        result.put(Constants.STATUS, status);
+        if (statusParams != null && statusParams.length > 0) {
+            result.put(Constants.MSG, MessageFormat.format(status.getMsg(), statusParams));
+        } else {
+            result.put(Constants.MSG, status.getMsg());
+        }
+    }
+
+    /**
+     * get mock Project
+     *
+     * @param projectName projectName
+     * @return Project
+     */
+    private Project getProject(String projectName) {
+        Project project = new Project();
+        project.setId(1);
+        project.setName(projectName);
+        project.setUserId(1);
+        return project;
+    }
+
+}

dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskInstanceServiceTest.java

@@ -267,4 +267,4 @@ public class TaskInstanceServiceTest {
         Map<String, Object> successRes = taskInstanceService.forceTaskSuccess(user, projectName, taskId);
         Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS));
     }
-}
+}

pom.xml

@@ -821,7 +821,8 @@
                         <include>**/api/service/LoggerServiceTest.java</include>
                         <include>**/api/service/MonitorServiceTest.java</include>
                         <include>**/api/service/ProcessDefinitionServiceTest.java</include>
-                        <include>**/api/service/ProcessDefinitionVersionServiceTest.java</include>
+                        <include>**/api/service/ProcessTaskRelationServiceImplTest.java</include>
+                        <include>**/api/service/TaskDefinitionServiceImplTest.java</include>
                         <include>**/api/service/ProcessInstanceServiceTest.java</include>
                         <include>**/api/service/ProjectServiceTest.java</include>
                         <include>**/api/service/QueueServiceTest.java</include>
@@ -970,7 +971,6 @@
                         <include>**/dao/mapper/DataSourceUserMapperTest.java</include>
                         <!--<iTaskUpdateQueueConsumerThreadnclude>**/dao/mapper/ErrorCommandMapperTest.java</iTaskUpdateQueueConsumerThreadnclude>-->
                         <include>**/dao/mapper/ProcessDefinitionMapperTest.java</include>
-                        <include>**/dao/mapper/ProcessDefinitionVersionMapperTest.java</include>
                         <include>**/dao/mapper/ProcessInstanceMapMapperTest.java</include>
                         <include>**/dao/mapper/ProcessInstanceMapperTest.java</include>
                         <include>**/dao/mapper/ProjectMapperTest.java</include>