[Test][api] Add api module `service` layer test example (#3521)

* [Test][api] Add api service layer test example

* Remove unused exception

* Remove unused exception

* Format code according to the checkstyle

* Fix test case

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

@@ -14,27 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.apache.dolphinscheduler.api.service.impl;
 
 import static org.apache.dolphinscheduler.common.Constants.CMDPARAM_SUB_PROCESS_DEFINE_ID;
 
-import java.io.BufferedOutputStream;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Collectors;
-import javax.servlet.ServletOutputStream;
-import javax.servlet.http.HttpServletResponse;
 import org.apache.dolphinscheduler.api.dto.ProcessMeta;
 import org.apache.dolphinscheduler.api.dto.treeview.Instance;
 import org.apache.dolphinscheduler.api.dto.treeview.TreeViewDto;
@@ -85,6 +69,26 @@ import org.apache.dolphinscheduler.dao.mapper.TaskInstanceMapper;
 import org.apache.dolphinscheduler.dao.utils.DagHelper;
 import org.apache.dolphinscheduler.service.permission.PermissionCheck;
 import org.apache.dolphinscheduler.service.process.ProcessService;
+
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -92,6 +96,7 @@ import org.springframework.http.MediaType;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
+
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fasterxml.jackson.core.JsonProcessingException;
@@ -100,7 +105,7 @@ import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 
 /**
- * process definition service
+ * process definition service impl
  */
 @Service
 public class ProcessDefinitionServiceImpl extends BaseService implements
@@ -156,7 +161,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
                                                        String locations,
                                                        String connects) throws JsonProcessingException {
 
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
         Project project = projectMapper.queryByName(projectName);
         // check project auth
         Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);
@@ -244,7 +249,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
      */
     public Map<String, Object> queryProcessDefinitionList(User loginUser, String projectName) {
 
-        HashMap<String, Object> result = new HashMap<>(5);
+        HashMap<String, Object> result = new HashMap<>();
         Project project = projectMapper.queryByName(projectName);
 
         Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);
@@ -274,7 +279,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
      */
     public Map<String, Object> queryProcessDefinitionListPaging(User loginUser, String projectName, String searchVal, Integer pageNo, Integer pageSize, Integer userId) {
 
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
         Project project = projectMapper.queryByName(projectName);
 
         Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);
@@ -283,11 +288,11 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
             return checkResult;
         }
 
-        Page<ProcessDefinition> page = new Page(pageNo, pageSize);
+        Page<ProcessDefinition> page = new Page<>(pageNo, pageSize);
         IPage<ProcessDefinition> processDefinitionIPage = processDefineMapper.queryDefineListPaging(
                 page, searchVal, userId, project.getId(), isAdmin(loginUser));
 
-        PageInfo pageInfo = new PageInfo<ProcessData>(pageNo, pageSize);
+        PageInfo<ProcessDefinition> pageInfo = new PageInfo<>(pageNo, pageSize);
         pageInfo.setTotalCount((int) processDefinitionIPage.getTotal());
         pageInfo.setLists(processDefinitionIPage.getRecords());
         result.put(Constants.DATA_LIST, pageInfo);
@@ -307,7 +312,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
     public Map<String, Object> queryProcessDefinitionById(User loginUser, String projectName, Integer processId) {
 
 
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
         Project project = projectMapper.queryByName(projectName);
 
         Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);
@@ -342,7 +347,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
     public Map<String, Object> updateProcessDefinition(User loginUser, String projectName, int id, String name,
                                                        String processDefinitionJson, String desc,
                                                        String locations, String connects) {
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
 
         Project project = projectMapper.queryByName(projectName);
         Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);
@@ -440,7 +445,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
     @Transactional(rollbackFor = RuntimeException.class)
     public Map<String, Object> deleteProcessDefinitionById(User loginUser, String projectName, Integer processDefinitionId) {
 
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
         Project project = projectMapper.queryByName(projectName);
 
         Map<String, Object> checkResult = projectService.checkProjectAndAuth(loginUser, project, projectName);
@@ -569,11 +574,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * batch export process definition by ids
-     *
-     * @param loginUser
-     * @param projectName
-     * @param processDefinitionIds
-     * @param response
      */
     public void batchExportProcessDefinitionByIds(User loginUser, String projectName, String processDefinitionIds, HttpServletResponse response) {
 
@@ -602,9 +602,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * get process definition list by ids
-     *
-     * @param processDefinitionIds
-     * @return
      */
     private List<ProcessMeta> getProcessDefinitionList(String processDefinitionIds) {
         List<ProcessMeta> processDefinitionList = new ArrayList<>();
@@ -623,9 +620,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * download the process definition file
-     *
-     * @param response
-     * @param processDefinitionList
      */
     private void downloadProcessDefinitionFile(HttpServletResponse response, List<ProcessMeta> processDefinitionList) {
         response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
@@ -657,18 +651,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
         }
     }
 
-    /**
-     * get export process metadata string
-     *
-     * @param processDefinitionId process definition id
-     * @param processDefinition   process definition
-     * @return export process metadata string
-     */
-    private String exportProcessMetaDataStr(Integer processDefinitionId, ProcessDefinition processDefinition) {
-        //create workflow json file
-        return JSONUtils.toJsonString(exportProcessMetaData(processDefinitionId, processDefinition));
-    }
-
     /**
      * get export process metadata string
      *
@@ -752,7 +734,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
      */
     @Transactional(rollbackFor = RuntimeException.class)
     public Map<String, Object> importProcessDefinition(User loginUser, MultipartFile file, String currentProjectName) {
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
         String processMetaJson = FileUtils.file2String(file);
         List<ProcessMeta> processMetaList = JSONUtils.toList(processMetaJson, ProcessMeta.class);
 
@@ -774,12 +756,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * check and import process definition
-     *
-     * @param loginUser
-     * @param currentProjectName
-     * @param result
-     * @param processMeta
-     * @return
      */
     private boolean checkAndImportProcessDefinition(User loginUser, String currentProjectName, Map<String, Object> result, ProcessMeta processMeta) {
 
@@ -821,8 +797,8 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
         //create process definition
         Integer processDefinitionId =
-                Objects.isNull(createProcessResult.get(PROCESSDEFINITIONID)) ?
+                Objects.isNull(createProcessResult.get(PROCESSDEFINITIONID))
-                        null : Integer.parseInt(createProcessResult.get(PROCESSDEFINITIONID).toString());
+                        ? null : Integer.parseInt(createProcessResult.get(PROCESSDEFINITIONID).toString());
 
         //scheduler param
         return getImportProcessScheduleResult(loginUser,
@@ -836,14 +812,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * get create process result
-     *
-     * @param loginUser
-     * @param currentProjectName
-     * @param result
-     * @param processMeta
-     * @param processDefinitionName
-     * @param importProcessParam
-     * @return
      */
     private Map<String, Object> getCreateProcessResult(User loginUser,
                                                        String currentProjectName,
@@ -871,14 +839,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * get import process schedule result
-     *
-     * @param loginUser
-     * @param currentProjectName
-     * @param result
-     * @param processMeta
-     * @param processDefinitionName
-     * @param processDefinitionId
-     * @return
      */
     private boolean getImportProcessScheduleResult(User loginUser,
                                                    String currentProjectName,
@@ -903,10 +863,6 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * check importance params
-     *
-     * @param processMeta
-     * @param result
-     * @return
      */
     private boolean checkImportanceParams(ProcessMeta processMeta, Map<String, Object> result) {
         if (StringUtils.isEmpty(processMeta.getProjectName())) {
@@ -924,6 +880,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
         return true;
     }
+
     /**
      * import process add special task param
      *
@@ -946,7 +903,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
         }
 
         //recursive sub-process parameter correction map key for old process id value for new process id
-        Map<Integer, Integer> subProcessIdMap = new HashMap<>(20);
+        Map<Integer, Integer> subProcessIdMap = new HashMap<>();
 
         List<Object> subProcessList = StreamUtils.asStream(jsonArray.elements())
                 .filter(elem -> checkTaskHasSubProcess(JSONUtils.parseObject(elem.toString()).path("type").asText()))
@@ -1111,7 +1068,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
      */
     public Map<String, Object> checkProcessNodeList(ProcessData processData, String processDefinitionJson) {
 
-        Map<String, Object> result = new HashMap<>(5);
+        Map<String, Object> result = new HashMap<>();
         try {
             if (processData == null) {
                 logger.error("process data is null");
@@ -1206,7 +1163,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
         for (String definitionId : idList) {
             idIntList.add(Integer.parseInt(definitionId));
         }
-        Integer[] idArray = idIntList.toArray(new Integer[idIntList.size()]);
+        Integer[] idArray = idIntList.toArray(new Integer[0]);
         List<ProcessDefinition> processDefinitionList = processDefineMapper.queryDefinitionListByIdList(idArray);
         if (CollectionUtils.isEmpty(processDefinitionList)) {
             logger.info("process definition not exists");
@@ -1237,7 +1194,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
      */
     public Map<String, Object> queryProcessDefinitionAllByProjectId(Integer projectId) {
 
-        HashMap<String, Object> result = new HashMap<>(5);
+        HashMap<String, Object> result = new HashMap<>();
 
         List<ProcessDefinition> resourceList = processDefineMapper.queryAllDefinitionList(projectId);
         result.put(Constants.DATA_LIST, resourceList);
@@ -1474,11 +1431,11 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * batch copy process definition
+     *
      * @param loginUser loginUser
      * @param projectName projectName
      * @param processDefinitionIds processDefinitionIds
      * @param targetProjectId targetProjectId
-     * @return
      */
     @Override
     public Map<String, Object> batchCopyProcessDefinition(User loginUser,
@@ -1522,11 +1479,11 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * batch move process definition
+     *
      * @param loginUser loginUser
      * @param projectName projectName
      * @param processDefinitionIds processDefinitionIds
      * @param targetProjectId targetProjectId
-     * @return
      */
     @Override
     public Map<String, Object> batchMoveProcessDefinition(User loginUser,
@@ -1570,6 +1527,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * do batch move process definition
+     *
      * @param targetProject targetProject
      * @param failedProcessList failedProcessList
      * @param processDefinitionIdList processDefinitionIdList
@@ -1591,6 +1549,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * batch copy process definition
+     *
      * @param loginUser loginUser
      * @param targetProject targetProject
      * @param failedProcessList failedProcessList
@@ -1613,6 +1572,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * set failed processList
+     *
      * @param failedProcessList failedProcessList
      * @param processDefinitionId processDefinitionId
      */
@@ -1627,9 +1587,9 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * check project and auth
+     *
      * @param loginUser loginUser
      * @param projectName projectName
-     * @return
      */
     private Map<String, Object> checkProjectAndAuth(User loginUser, String projectName) {
         Project project = projectMapper.queryByName(projectName);
@@ -1646,6 +1606,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * move process definition
+     *
      * @param processId processId
      * @param targetProject targetProject
      * @return move result code
@@ -1673,6 +1634,7 @@ public class ProcessDefinitionServiceImpl extends BaseService implements
 
     /**
      * check batch operate result
+     *
      * @param srcProjectName srcProjectName
      * @param targetProjectName targetProjectName
      * @param result result

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

@@ -30,6 +30,7 @@ import org.apache.dolphinscheduler.common.enums.WarningType;
 import org.apache.dolphinscheduler.common.utils.DateUtils;
 import org.apache.dolphinscheduler.common.utils.FileUtils;
 import org.apache.dolphinscheduler.common.utils.JSONUtils;
+import org.apache.dolphinscheduler.common.utils.StringUtils;
 import org.apache.dolphinscheduler.dao.entity.DataSource;
 import org.apache.dolphinscheduler.dao.entity.ProcessData;
 import org.apache.dolphinscheduler.dao.entity.ProcessDefinition;
@@ -38,7 +39,6 @@ import org.apache.dolphinscheduler.dao.entity.Project;
 import org.apache.dolphinscheduler.dao.entity.Schedule;
 import org.apache.dolphinscheduler.dao.entity.TaskInstance;
 import org.apache.dolphinscheduler.dao.entity.User;
-import org.apache.dolphinscheduler.dao.mapper.DataSourceMapper;
 import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionMapper;
 import org.apache.dolphinscheduler.dao.mapper.ProcessInstanceMapper;
 import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
@@ -68,14 +68,14 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.springframework.mock.web.MockMultipartFile;
 import org.springframework.web.multipart.MultipartFile;
 
-@RunWith(MockitoJUnitRunner.Silent.class)
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+
+@RunWith(MockitoJUnitRunner.class)
 public class ProcessDefinitionServiceTest {
 
     @InjectMocks
-    ProcessDefinitionServiceImpl processDefinitionService;
+    private ProcessDefinitionServiceImpl processDefinitionService;
-
-    @Mock
-    private DataSourceMapper dataSourceMapper;
 
     @Mock
     private ProcessDefinitionMapper processDefineMapper;
@@ -98,28 +98,149 @@ public class ProcessDefinitionServiceTest {
     @Mock
     private TaskInstanceMapper taskInstanceMapper;
 
-    private String sqlDependentJson = "{\"globalParams\":[]," +
+    private static final String SHELL_JSON = "{\n"
-            "\"tasks\":[{\"type\":\"SQL\",\"id\":\"tasks-27297\",\"name\":\"sql\"," +
+            + "    \"globalParams\": [\n"
-            "\"params\":{\"type\":\"MYSQL\",\"datasource\":1,\"sql\":\"select * from test\"," +
+            + "        \n"
-            "\"udfs\":\"\",\"sqlType\":\"1\",\"title\":\"\",\"receivers\":\"\",\"receiversCc\":\"\",\"showType\":\"TABLE\"" +
+            + "    ],\n"
-            ",\"localParams\":[],\"connParams\":\"\"," +
+            + "    \"tasks\": [\n"
-            "\"preStatements\":[],\"postStatements\":[]}," +
+            + "        {\n"
-            "\"description\":\"\",\"runFlag\":\"NORMAL\",\"dependence\":{},\"maxRetryTimes\":\"0\"," +
+            + "            \"type\": \"SHELL\",\n"
-            "\"retryInterval\":\"1\",\"timeout\":{\"strategy\":\"\"," +
+            + "            \"id\": \"tasks-9527\",\n"
-            "\"enable\":false},\"taskInstancePriority\":\"MEDIUM\",\"workerGroupId\":-1," +
+            + "            \"name\": \"shell-1\",\n"
-            "\"preTasks\":[\"dependent\"]},{\"type\":\"DEPENDENT\",\"id\":\"tasks-33787\"," +
+            + "            \"params\": {\n"
-            "\"name\":\"dependent\",\"params\":{},\"description\":\"\",\"runFlag\":\"NORMAL\"," +
+            + "                \"resourceList\": [\n"
-            "\"dependence\":{\"relation\":\"AND\",\"dependTaskList\":[{\"relation\":\"AND\"," +
+            + "                    \n"
-            "\"dependItemList\":[{\"projectId\":2,\"definitionId\":46,\"depTasks\":\"ALL\"," +
+            + "                ],\n"
-            "\"cycle\":\"day\",\"dateValue\":\"today\"}]}]},\"maxRetryTimes\":\"0\",\"retryInterval\":\"1\"," +
+            + "                \"localParams\": [\n"
-            "\"timeout\":{\"strategy\":\"\",\"enable\":false},\"taskInstancePriority\":\"MEDIUM\"," +
+            + "                    \n"
-            "\"workerGroupId\":-1,\"preTasks\":[]}],\"tenantId\":1,\"timeout\":0}";
+            + "                ],\n"
-
+            + "                \"rawScript\": \"#!/bin/bash\\necho \\\"shell-1\\\"\"\n"
-    private String shellJson = "{\"globalParams\":[],\"tasks\":[{\"type\":\"SHELL\",\"id\":\"tasks-9527\",\"name\":\"shell-1\"," +
+            + "            },\n"
-            "\"params\":{\"resourceList\":[],\"localParams\":[],\"rawScript\":\"#!/bin/bash\\necho \\\"shell-1\\\"\"}," +
+            + "            \"description\": \"\",\n"
-            "\"description\":\"\",\"runFlag\":\"NORMAL\",\"dependence\":{},\"maxRetryTimes\":\"0\",\"retryInterval\":\"1\"," +
+            + "            \"runFlag\": \"NORMAL\",\n"
-            "\"timeout\":{\"strategy\":\"\",\"interval\":1,\"enable\":false},\"taskInstancePriority\":\"MEDIUM\"," +
+            + "            \"dependence\": {\n"
-            "\"workerGroupId\":-1,\"preTasks\":[]}],\"tenantId\":1,\"timeout\":0}";
+            + "                \n"
+            + "            },\n"
+            + "            \"maxRetryTimes\": \"0\",\n"
+            + "            \"retryInterval\": \"1\",\n"
+            + "            \"timeout\": {\n"
+            + "                \"strategy\": \"\",\n"
+            + "                \"interval\": 1,\n"
+            + "                \"enable\": false\n"
+            + "            },\n"
+            + "            \"taskInstancePriority\": \"MEDIUM\",\n"
+            + "            \"workerGroupId\": -1,\n"
+            + "            \"preTasks\": [\n"
+            + "                \n"
+            + "            ]\n"
+            + "        }\n"
+            + "    ],\n"
+            + "    \"tenantId\": 1,\n"
+            + "    \"timeout\": 0\n"
+            + "}";
+
+    private static final String CYCLE_SHELL_JSON = "{\n"
+            + "    \"globalParams\": [\n"
+            + "        \n"
+            + "    ],\n"
+            + "    \"tasks\": [\n"
+            + "        {\n"
+            + "            \"type\": \"SHELL\",\n"
+            + "            \"id\": \"tasks-9527\",\n"
+            + "            \"name\": \"shell-1\",\n"
+            + "            \"params\": {\n"
+            + "                \"resourceList\": [\n"
+            + "                    \n"
+            + "                ],\n"
+            + "                \"localParams\": [\n"
+            + "                    \n"
+            + "                ],\n"
+            + "                \"rawScript\": \"#!/bin/bash\\necho \\\"shell-1\\\"\"\n"
+            + "            },\n"
+            + "            \"description\": \"\",\n"
+            + "            \"runFlag\": \"NORMAL\",\n"
+            + "            \"dependence\": {\n"
+            + "                \n"
+            + "            },\n"
+            + "            \"maxRetryTimes\": \"0\",\n"
+            + "            \"retryInterval\": \"1\",\n"
+            + "            \"timeout\": {\n"
+            + "                \"strategy\": \"\",\n"
+            + "                \"interval\": 1,\n"
+            + "                \"enable\": false\n"
+            + "            },\n"
+            + "            \"taskInstancePriority\": \"MEDIUM\",\n"
+            + "            \"workerGroupId\": -1,\n"
+            + "            \"preTasks\": [\n"
+            + "                \"tasks-9529\"\n"
+            + "            ]\n"
+            + "        },\n"
+            + "        {\n"
+            + "            \"type\": \"SHELL\",\n"
+            + "            \"id\": \"tasks-9528\",\n"
+            + "            \"name\": \"shell-1\",\n"
+            + "            \"params\": {\n"
+            + "                \"resourceList\": [\n"
+            + "                    \n"
+            + "                ],\n"
+            + "                \"localParams\": [\n"
+            + "                    \n"
+            + "                ],\n"
+            + "                \"rawScript\": \"#!/bin/bash\\necho \\\"shell-1\\\"\"\n"
+            + "            },\n"
+            + "            \"description\": \"\",\n"
+            + "            \"runFlag\": \"NORMAL\",\n"
+            + "            \"dependence\": {\n"
+            + "                \n"
+            + "            },\n"
+            + "            \"maxRetryTimes\": \"0\",\n"
+            + "            \"retryInterval\": \"1\",\n"
+            + "            \"timeout\": {\n"
+            + "                \"strategy\": \"\",\n"
+            + "                \"interval\": 1,\n"
+            + "                \"enable\": false\n"
+            + "            },\n"
+            + "            \"taskInstancePriority\": \"MEDIUM\",\n"
+            + "            \"workerGroupId\": -1,\n"
+            + "            \"preTasks\": [\n"
+            + "                \"tasks-9527\"\n"
+            + "            ]\n"
+            + "        },\n"
+            + "        {\n"
+            + "            \"type\": \"SHELL\",\n"
+            + "            \"id\": \"tasks-9529\",\n"
+            + "            \"name\": \"shell-1\",\n"
+            + "            \"params\": {\n"
+            + "                \"resourceList\": [\n"
+            + "                    \n"
+            + "                ],\n"
+            + "                \"localParams\": [\n"
+            + "                    \n"
+            + "                ],\n"
+            + "                \"rawScript\": \"#!/bin/bash\\necho \\\"shell-1\\\"\"\n"
+            + "            },\n"
+            + "            \"description\": \"\",\n"
+            + "            \"runFlag\": \"NORMAL\",\n"
+            + "            \"dependence\": {\n"
+            + "                \n"
+            + "            },\n"
+            + "            \"maxRetryTimes\": \"0\",\n"
+            + "            \"retryInterval\": \"1\",\n"
+            + "            \"timeout\": {\n"
+            + "                \"strategy\": \"\",\n"
+            + "                \"interval\": 1,\n"
+            + "                \"enable\": false\n"
+            + "            },\n"
+            + "            \"taskInstancePriority\": \"MEDIUM\",\n"
+            + "            \"workerGroupId\": -1,\n"
+            + "            \"preTasks\": [\n"
+            + "                \"tasks-9528\"\n"
+            + "            ]\n"
+            + "        }\n"
+            + "    ],\n"
+            + "    \"tenantId\": 1,\n"
+            + "    \"timeout\": 0\n"
+            + "}";
 
     @Test
     public void testQueryProcessDefinitionList() {
@@ -150,6 +271,7 @@ public class ProcessDefinitionServiceTest {
     }
 
     @Test
+    @SuppressWarnings("unchecked")
     public void testQueryProcessDefinitionListPaging() {
         String projectName = "project_test1";
         Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
@@ -168,6 +290,22 @@ public class ProcessDefinitionServiceTest {
         Map<String, Object> map = processDefinitionService.queryProcessDefinitionListPaging(loginUser, "project_test1", "", 1, 5, 0);
         Assert.assertEquals(Status.PROJECT_NOT_FOUNT, map.get(Constants.STATUS));
 
+        putMsg(result, Status.SUCCESS, projectName);
+        loginUser.setId(1);
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+        Page<ProcessDefinition> page = new Page<>(1, 10);
+        page.setTotal(30);
+        Mockito.when(processDefineMapper.queryDefineListPaging(
+                Mockito.any(IPage.class)
+                , Mockito.eq("")
+                , Mockito.eq(loginUser.getId())
+                , Mockito.eq(project.getId())
+                , Mockito.anyBoolean())).thenReturn(page);
+
+        Map<String, Object> map1 = processDefinitionService.queryProcessDefinitionListPaging(
+                loginUser, projectName, "", 1, 10, loginUser.getId());
+
+        Assert.assertEquals(Status.SUCCESS, map1.get(Constants.STATUS));
     }
 
     @Test
@@ -206,55 +344,72 @@ public class ProcessDefinitionServiceTest {
     }
 
     @Test
-    public void testCopyProcessDefinition() throws Exception {
+    public void testBatchCopyProcessDefinition() {
-        String projectName = "project_test1";
-        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
-
-        Mockito.when(projectMapper.queryDetailById(1)).thenReturn(getProject(projectName));
 
+        String projectName = "project_test1";
         Project project = getProject(projectName);
 
         User loginUser = new User();
         loginUser.setId(-1);
         loginUser.setUserType(UserType.GENERAL_USER);
 
+        // copy project definition ids empty test
+        Map<String, Object> map = processDefinitionService.batchCopyProcessDefinition(loginUser, projectName, StringUtils.EMPTY, 0);
+        Assert.assertEquals(Status.PROCESS_DEFINITION_IDS_IS_EMPTY, map.get(Constants.STATUS));
+
         Map<String, Object> result = new HashMap<>();
-        //project check auth success, instance not exist
+
+        // project check auth fail
+        putMsg(result, Status.PROJECT_NOT_FOUNT, projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+        Map<String, Object> map1 = processDefinitionService.batchCopyProcessDefinition(
+                loginUser, projectName, String.valueOf(project.getId()), 0);
+        Assert.assertEquals(Status.PROJECT_NOT_FOUNT, map1.get(Constants.STATUS));
+
+        // project check auth success, target project is null
         putMsg(result, Status.SUCCESS, projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+        Mockito.when(projectMapper.queryDetailById(0)).thenReturn(null);
+        Map<String, Object> map2 = processDefinitionService.batchCopyProcessDefinition(
+                loginUser, projectName, String.valueOf(project.getId()), 0);
+        Assert.assertEquals(Status.PROJECT_NOT_FOUNT, map2.get(Constants.STATUS));
+
+        // project check auth success, target project name not equal project name, check auth target project fail
+        Project project1 = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project1);
         Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
 
+        putMsg(result, Status.SUCCESS, projectName);
+        String projectName2 = "project_test2";
+        Project project2 = getProject(projectName2);
+        Mockito.when(projectMapper.queryByName(projectName2)).thenReturn(project2);
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project2, projectName2)).thenReturn(result);
+        Mockito.when(projectMapper.queryDetailById(1)).thenReturn(project2);
+        // instance exit
         ProcessDefinition definition = getProcessDefinition();
         definition.setLocations("{\"tasks-36196\":{\"name\":\"ssh_test1\",\"targetarr\":\"\",\"x\":141,\"y\":70}}");
         definition.setProcessDefinitionJson("{\"globalParams\":[],\"tasks\":[{\"type\":\"SHELL\",\"id\":\"tasks-36196\",\"name\":\"ssh_test1\",\"params\":{\"resourceList\":[],\"localParams\":[],\"rawScript\":\"aa=\\\"1234\\\"\\necho ${aa}\"},\"desc\":\"\",\"runFlag\":\"NORMAL\",\"dependence\":{},\"maxRetryTimes\":\"0\",\"retryInterval\":\"1\",\"timeout\":{\"strategy\":\"\",\"interval\":null,\"enable\":false},\"taskInstancePriority\":\"MEDIUM\",\"workerGroupId\":-1,\"preTasks\":[]}],\"tenantId\":-1,\"timeout\":0}");
         definition.setConnects("[]");
-        //instance exit
-        Mockito.when(processDefineMapper.selectById(46)).thenReturn(definition);
 
-        Map<String, Object> createProcessResult = new HashMap<>();
+        Mockito.when(processDefineMapper.selectById(46)).thenReturn(definition);
-        putMsg(result, Status.SUCCESS);
-
-        Mockito.when(processDefinitionService.createProcessDefinition(
-                loginUser,
-                definition.getProjectName(),
-                definition.getName(),
-                definition.getProcessDefinitionJson(),
-                definition.getDescription(),
-                definition.getLocations(),
-                definition.getConnects())).thenReturn(createProcessResult);
 
-        Map<String, Object> successRes = processDefinitionService.batchCopyProcessDefinition(loginUser, "project_test1",
+        Map<String, Object> map3 = processDefinitionService.batchCopyProcessDefinition(
-                "46", 1);
+                loginUser, projectName, "46", 1);
+        Assert.assertEquals(Status.SUCCESS, map3.get(Constants.STATUS));
 
-        Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS));
     }
 
     @Test
-    public void testBatchMoveProcessDefinition() throws Exception {
+    public void testBatchMoveProcessDefinition() {
         String projectName = "project_test1";
-        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
+        Project project1 = getProject(projectName);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project1);
 
         String projectName2 = "project_test2";
-        Mockito.when(projectMapper.queryByName(projectName2)).thenReturn(getProject(projectName2));
+        Project project2 = getProject(projectName2);
+        Mockito.when(projectMapper.queryByName(projectName2)).thenReturn(project2);
 
         int targetProjectId = 2;
         Mockito.when(projectMapper.queryDetailById(targetProjectId)).thenReturn(getProjectById(targetProjectId));
@@ -273,27 +428,27 @@ public class ProcessDefinitionServiceTest {
         putMsg(result2, Status.SUCCESS, targetProject.getName());
 
         Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
-        Mockito.when(projectService.checkProjectAndAuth(loginUser, targetProject, targetProject.getName())).thenReturn(result2);
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project2, projectName2)).thenReturn(result);
 
         ProcessDefinition definition = getProcessDefinition();
         definition.setLocations("{\"tasks-36196\":{\"name\":\"ssh_test1\",\"targetarr\":\"\",\"x\":141,\"y\":70}}");
         definition.setProcessDefinitionJson("{\"globalParams\":[],\"tasks\":[{\"type\":\"SHELL\",\"id\":\"tasks-36196\",\"name\":\"ssh_test1\",\"params\":{\"resourceList\":[],\"localParams\":[],\"rawScript\":\"aa=\\\"1234\\\"\\necho ${aa}\"},\"desc\":\"\",\"runFlag\":\"NORMAL\",\"dependence\":{},\"maxRetryTimes\":\"0\",\"retryInterval\":\"1\",\"timeout\":{\"strategy\":\"\",\"interval\":null,\"enable\":false},\"taskInstancePriority\":\"MEDIUM\",\"workerGroupId\":-1,\"preTasks\":[]}],\"tenantId\":-1,\"timeout\":0}");
         definition.setConnects("[]");
-        //instance exit
+
+        // check target project result == null
         Mockito.when(processDefineMapper.updateById(definition)).thenReturn(46);
         Mockito.when(processDefineMapper.selectById(46)).thenReturn(definition);
 
         putMsg(result, Status.SUCCESS);
 
-
+        Map<String, Object> successRes = processDefinitionService.batchMoveProcessDefinition(
-        Map<String, Object> successRes = processDefinitionService.batchMoveProcessDefinition(loginUser, "project_test1",
+                loginUser, "project_test1", "46", 2);
-                "46", 2);
 
         Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS));
     }
 
     @Test
-    public void deleteProcessDefinitionByIdTest() throws Exception {
+    public void deleteProcessDefinitionByIdTest() {
         String projectName = "project_test1";
         Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
 
@@ -379,7 +534,7 @@ public class ProcessDefinitionServiceTest {
 
         Project project = getProject(projectName);
         User loginUser = new User();
-        loginUser.setId(-1);
+        loginUser.setId(1);
         loginUser.setUserType(UserType.GENERAL_USER);
 
         //project check auth fail
@@ -393,14 +548,22 @@ public class ProcessDefinitionServiceTest {
         // project check auth success, processs definition online
         putMsg(result, Status.SUCCESS, projectName);
         Mockito.when(processDefineMapper.selectById(46)).thenReturn(getProcessDefinition());
-        Mockito.when(processDefineMapper.updateById(getProcessDefinition())).thenReturn(1);
+        Map<String, Object> onlineRes = processDefinitionService.releaseProcessDefinition(
-        Map<String, Object> onlineRes = processDefinitionService.releaseProcessDefinition(loginUser, "project_test1",
+                loginUser, "project_test1", 46, ReleaseState.ONLINE.getCode());
-                46, ReleaseState.ONLINE.getCode());
         Assert.assertEquals(Status.SUCCESS, onlineRes.get(Constants.STATUS));
 
+        // project check auth success, processs definition online
+        ProcessDefinition processDefinition1 = getProcessDefinition();
+        processDefinition1.setResourceIds("1,2");
+        Mockito.when(processDefineMapper.selectById(46)).thenReturn(processDefinition1);
+        Mockito.when(processService.getUserById(1)).thenReturn(loginUser);
+        Map<String, Object> onlineWithResourceRes = processDefinitionService.releaseProcessDefinition(
+                loginUser, "project_test1", 46, ReleaseState.ONLINE.getCode());
+        Assert.assertEquals(Status.SUCCESS, onlineWithResourceRes.get(Constants.STATUS));
+
         // release error code
-        Map<String, Object> failRes = processDefinitionService.releaseProcessDefinition(loginUser, "project_test1",
+        Map<String, Object> failRes = processDefinitionService.releaseProcessDefinition(
-                46, 2);
+                loginUser, "project_test1", 46, 2);
         Assert.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR, failRes.get(Constants.STATUS));
 
         //FIXME has function exit code 1 when exception
@@ -454,9 +617,9 @@ public class ProcessDefinitionServiceTest {
         Assert.assertEquals(Status.DATA_IS_NOT_VALID, dataNotValidRes.get(Constants.STATUS));
 
         // task not empty
-        String processDefinitionJson = shellJson;
+        String processDefinitionJson = SHELL_JSON;
         ProcessData processData = JSONUtils.parseObject(processDefinitionJson, ProcessData.class);
-        assert processData != null;
+        Assert.assertNotNull(processData);
         Map<String, Object> taskEmptyRes = processDefinitionService.checkProcessNodeList(processData, processDefinitionJson);
         Assert.assertEquals(Status.SUCCESS, taskEmptyRes.get(Constants.STATUS));
 
@@ -465,6 +628,12 @@ public class ProcessDefinitionServiceTest {
         Map<String, Object> taskNotEmptyRes = processDefinitionService.checkProcessNodeList(processData, processDefinitionJson);
         Assert.assertEquals(Status.DATA_IS_NULL, taskNotEmptyRes.get(Constants.STATUS));
 
+        // task cycle
+        String processDefinitionJsonCycle = CYCLE_SHELL_JSON;
+        ProcessData processDataCycle = JSONUtils.parseObject(processDefinitionJsonCycle, ProcessData.class);
+        Map<String, Object> taskCycleRes = processDefinitionService.checkProcessNodeList(processDataCycle, processDefinitionJsonCycle);
+        Assert.assertEquals(Status.PROCESS_NODE_HAS_CYCLE, taskCycleRes.get(Constants.STATUS));
+
         //json abnormal
         String abnormalJson = processDefinitionJson.replaceAll("SHELL", "");
         processData = JSONUtils.parseObject(abnormalJson, ProcessData.class);
@@ -473,7 +642,7 @@ public class ProcessDefinitionServiceTest {
     }
 
     @Test
-    public void testGetTaskNodeListByDefinitionId() throws Exception {
+    public void testGetTaskNodeListByDefinitionId() {
         //process definition not exist
         Mockito.when(processDefineMapper.selectById(46)).thenReturn(null);
         Map<String, Object> processDefinitionNullRes = processDefinitionService.getTaskNodeListByDefinitionId(46);
@@ -486,14 +655,14 @@ public class ProcessDefinitionServiceTest {
         Assert.assertEquals(Status.DATA_IS_NOT_VALID, successRes.get(Constants.STATUS));
 
         //success
-        processDefinition.setProcessDefinitionJson(shellJson);
+        processDefinition.setProcessDefinitionJson(SHELL_JSON);
         Mockito.when(processDefineMapper.selectById(46)).thenReturn(processDefinition);
         Map<String, Object> dataNotValidRes = processDefinitionService.getTaskNodeListByDefinitionId(46);
         Assert.assertEquals(Status.SUCCESS, dataNotValidRes.get(Constants.STATUS));
     }
 
     @Test
-    public void testGetTaskNodeListByDefinitionIdList() throws Exception {
+    public void testGetTaskNodeListByDefinitionIdList() {
         //process definition not exist
         String defineIdList = "46";
         Integer[] idArray = {46};
@@ -503,7 +672,7 @@ public class ProcessDefinitionServiceTest {
 
         //process definition exist
         ProcessDefinition processDefinition = getProcessDefinition();
-        processDefinition.setProcessDefinitionJson(shellJson);
+        processDefinition.setProcessDefinitionJson(SHELL_JSON);
         List<ProcessDefinition> processDefinitionList = new ArrayList<>();
         processDefinitionList.add(processDefinition);
         Mockito.when(processDefineMapper.queryDefinitionListByIdList(idArray)).thenReturn(processDefinitionList);
@@ -515,7 +684,7 @@ public class ProcessDefinitionServiceTest {
     public void testQueryProcessDefinitionAllByProjectId() {
         int projectId = 1;
         ProcessDefinition processDefinition = getProcessDefinition();
-        processDefinition.setProcessDefinitionJson(shellJson);
+        processDefinition.setProcessDefinitionJson(SHELL_JSON);
         List<ProcessDefinition> processDefinitionList = new ArrayList<>();
         processDefinitionList.add(processDefinition);
         Mockito.when(processDefineMapper.queryAllDefinitionList(projectId)).thenReturn(processDefinitionList);
@@ -527,7 +696,7 @@ public class ProcessDefinitionServiceTest {
     public void testViewTree() throws Exception {
         //process definition not exist
         ProcessDefinition processDefinition = getProcessDefinition();
-        processDefinition.setProcessDefinitionJson(shellJson);
+        processDefinition.setProcessDefinitionJson(SHELL_JSON);
         Mockito.when(processDefineMapper.selectById(46)).thenReturn(null);
         Map<String, Object> processDefinitionNullRes = processDefinitionService.viewTree(46, 10);
         Assert.assertEquals(Status.PROCESS_DEFINE_NOT_EXIST, processDefinitionNullRes.get(Constants.STATUS));
@@ -567,29 +736,71 @@ public class ProcessDefinitionServiceTest {
     @Test
     public void testImportProcessDefinitionById() throws IOException {
 
-        String processJson = "[{\"projectName\":\"testProject\",\"processDefinitionName\":\"shell-4\"," +
+        String processJson = "[\n"
-                "\"processDefinitionJson\":\"{\\\"tenantId\\\":1,\\\"globalParams\\\":[]," +
+                + "    {\n"
-                "\\\"tasks\\\":[{\\\"workerGroupId\\\":\\\"default\\\",\\\"description\\\":\\\"\\\",\\\"runFlag\\\":\\\"NORMAL\\\"," +
+                + "        \"projectName\": \"testProject\",\n"
-                "\\\"type\\\":\\\"SHELL\\\",\\\"params\\\":{\\\"rawScript\\\":\\\"#!/bin/bash\\\\necho \\\\\\\"shell-4\\\\\\\"\\\"," +
+                + "        \"processDefinitionName\": \"shell-4\",\n"
-                "\\\"localParams\\\":[],\\\"resourceList\\\":[]},\\\"timeout\\\":{\\\"enable\\\":false,\\\"strategy\\\":\\\"\\\"}," +
+                + "        \"processDefinitionJson\": \"{\\\"tenantId\\\":1"
-                "\\\"maxRetryTimes\\\":\\\"0\\\",\\\"taskInstancePriority\\\":\\\"MEDIUM\\\",\\\"name\\\":\\\"shell-4\\\"," +
+                + ",\\\"globalParams\\\":[],\\\"tasks\\\":[{\\\"workerGroupId\\\":\\\"3\\\",\\\"description\\\""
-                "\\\"dependence\\\":{},\\\"retryInterval\\\":\\\"1\\\",\\\"preTasks\\\":[],\\\"id\\\":\\\"tasks-84090\\\"}," +
+                + ":\\\"\\\",\\\"runFlag\\\":\\\"NORMAL\\\",\\\"type\\\":\\\"SHELL\\\",\\\"params\\\":{\\\"rawScript\\\""
-                "{\\\"taskInstancePriority\\\":\\\"MEDIUM\\\",\\\"name\\\":\\\"shell-5\\\",\\\"workerGroupId\\\":\\\"default\\\\," +
+                + ":\\\"#!/bin/bash\\\\necho \\\\\\\"shell-4\\\\\\\"\\\",\\\"localParams\\\":[],\\\"resourceList\\\":[]}"
-                "\\\"description\\\":\\\"\\\",\\\"dependence\\\":{},\\\"preTasks\\\":[\\\"shell-4\\\"],\\\"id\\\":\\\"tasks-87364\\\"," +
+                + ",\\\"timeout\\\":{\\\"enable\\\":false,\\\"strategy\\\":\\\"\\\"},\\\"maxRetryTimes\\\":\\\"0\\\""
-                "\\\"runFlag\\\":\\\"NORMAL\\\",\\\"type\\\":\\\"SUB_PROCESS\\\",\\\"params\\\":{\\\"processDefinitionId\\\":46}," +
+                + ",\\\"taskInstancePriority\\\":\\\"MEDIUM\\\",\\\"name\\\":\\\"shell-4\\\",\\\"dependence\\\":{}"
-                "\\\"timeout\\\":{\\\"enable\\\":false,\\\"strategy\\\":\\\"\\\"}}],\\\"timeout\\\":0}\"," +
+                + ",\\\"retryInterval\\\":\\\"1\\\",\\\"preTasks\\\":[],\\\"id\\\":\\\"tasks-84090\\\"}"
-                "\"processDefinitionDescription\":\"\",\"processDefinitionLocations\":\"{\\\"tasks-84090\\\":{\\\"name\\\":\\\"shell-4\\\"," +
+                + ",{\\\"taskInstancePriority\\\":\\\"MEDIUM\\\",\\\"name\\\":\\\"shell-5\\\",\\\"workerGroupId\\\""
-                "\\\"targetarr\\\":\\\"\\\",\\\"x\\\":128,\\\"y\\\":114},\\\"tasks-87364\\\":{\\\"name\\\":\\\"shell-5\\\"," +
+                + ":\\\"3\\\",\\\"description\\\":\\\"\\\",\\\"dependence\\\":{},\\\"preTasks\\\":[\\\"shell-4\\\"]"
-                "\\\"targetarr\\\":\\\"tasks-84090\\\",\\\"x\\\":266,\\\"y\\\":115}}\"," +
+                + ",\\\"id\\\":\\\"tasks-87364\\\",\\\"runFlag\\\":\\\"NORMAL\\\",\\\"type\\\":\\\"SUB_PROCESS\\\""
-                "\"processDefinitionConnects\":\"[{\\\"endPointSourceId\\\":\\\"tasks-84090\\\"," +
+                + ",\\\"params\\\":{\\\"processDefinitionId\\\":46},\\\"timeout\\\":{\\\"enable\\\":false"
-                "\\\"endPointTargetId\\\":\\\"tasks-87364\\\"}]\"}]";
+                + ",\\\"strategy\\\":\\\"\\\"}}],\\\"timeout\\\":0}\",\n"
-
+                + "        \"processDefinitionDescription\": \"\",\n"
-        String subProcessJson = "{\"globalParams\":[]," +
+                + "        \"processDefinitionLocations\": \"{\\\"tasks-84090\\\":{\\\"name\\\":\\\"shell-4\\\""
-                "\"tasks\":[{\"type\":\"SHELL\",\"id\":\"tasks-52423\",\"name\":\"shell-5\"," +
+                + ",\\\"targetarr\\\":\\\"\\\",\\\"x\\\":128,\\\"y\\\":114},\\\"tasks-87364\\\":{\\\"name\\\""
-                "\"params\":{\"resourceList\":[],\"localParams\":[],\"rawScript\":\"echo \\\"shell-5\\\"\"},\"description\":\"\"," +
+                + ":\\\"shell-5\\\",\\\"targetarr\\\":\\\"tasks-84090\\\",\\\"x\\\":266,\\\"y\\\":115}}\",\n"
-                "\"runFlag\":\"NORMAL\",\"dependence\":{},\"maxRetryTimes\":\"0\",\"retryInterval\":\"1\"," +
+                + "        \"processDefinitionConnects\": \"[{\\\"endPointSourceId\\\":\\\"tasks-84090\\\""
-                "\"timeout\":{\"strategy\":\"\",\"interval\":null,\"enable\":false},\"taskInstancePriority\":\"MEDIUM\",\"workerGroupId\":\\\"default\\\\," +
+                + ",\\\"endPointTargetId\\\":\\\"tasks-87364\\\"}]\"\n"
-                "\"preTasks\":[]}],\"tenantId\":1,\"timeout\":0}";
+                + "    }\n"
+                + "]";
+
+        String subProcessJson = "{\n"
+                + "    \"globalParams\": [\n"
+                + "        \n"
+                + "    ],\n"
+                + "    \"tasks\": [\n"
+                + "        {\n"
+                + "            \"type\": \"SHELL\",\n"
+                + "            \"id\": \"tasks-52423\",\n"
+                + "            \"name\": \"shell-5\",\n"
+                + "            \"params\": {\n"
+                + "                \"resourceList\": [\n"
+                + "                    \n"
+                + "                ],\n"
+                + "                \"localParams\": [\n"
+                + "                    \n"
+                + "                ],\n"
+                + "                \"rawScript\": \"echo \\\"shell-5\\\"\"\n"
+                + "            },\n"
+                + "            \"description\": \"\",\n"
+                + "            \"runFlag\": \"NORMAL\",\n"
+                + "            \"dependence\": {\n"
+                + "                \n"
+                + "            },\n"
+                + "            \"maxRetryTimes\": \"0\",\n"
+                + "            \"retryInterval\": \"1\",\n"
+                + "            \"timeout\": {\n"
+                + "                \"strategy\": \"\",\n"
+                + "                \"interval\": null,\n"
+                + "                \"enable\": false\n"
+                + "            },\n"
+                + "            \"taskInstancePriority\": \"MEDIUM\",\n"
+                + "            \"workerGroupId\": \"3\",\n"
+                + "            \"preTasks\": [\n"
+                + "                \n"
+                + "            ]\n"
+                + "        }\n"
+                + "    ],\n"
+                + "    \"tenantId\": 1,\n"
+                + "    \"timeout\": 0\n"
+                + "}";
 
         FileUtils.writeStringToFile(new File("/tmp/task.json"), processJson);
 
@@ -618,28 +829,13 @@ public class ProcessDefinitionServiceTest {
         Mockito.when(projectService.checkProjectAndAuth(loginUser, getProject(currentProjectName), currentProjectName)).thenReturn(result);
         Mockito.when(processDefineMapper.queryByDefineId(46)).thenReturn(shellDefinition2);
 
-        //import process
+        Map<String, Object> importProcessResult = processDefinitionService.importProcessDefinition(loginUser, multipartFile, currentProjectName);
-//        Map<String, Object> importProcessResult = processDefinitionService.importProcessDefinition(loginUser, multipartFile, currentProjectName);
+
-//
+        Assert.assertEquals(Status.SUCCESS, importProcessResult.get(Constants.STATUS));
-//        Assert.assertEquals(Status.SUCCESS, importProcessResult.get(Constants.STATUS));
-//
-//        boolean delete = file.delete();
-//
-//        Assert.assertTrue(delete);
-
-//        String processMetaJson = "";
-//        improssProcessCheckData(file, loginUser, currentProjectName, processMetaJson);
-//
-//        processMetaJson = "{\"scheduleWorkerGroupId\":-1}";
-//        improssProcessCheckData(file, loginUser, currentProjectName, processMetaJson);
-//
-//        processMetaJson = "{\"scheduleWorkerGroupId\":-1,\"projectName\":\"test\"}";
-//        improssProcessCheckData(file, loginUser, currentProjectName, processMetaJson);
-//
-//        processMetaJson = "{\"scheduleWorkerGroupId\":-1,\"projectName\":\"test\",\"processDefinitionName\":\"test_definition\"}";
-//        improssProcessCheckData(file, loginUser, currentProjectName, processMetaJson);
 
+        boolean delete = file.delete();
 
+        Assert.assertTrue(delete);
     }
 
     @Test
@@ -658,12 +854,122 @@ public class ProcessDefinitionServiceTest {
         Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
         Mockito.when(processService.findProcessDefineById(1)).thenReturn(getProcessDefinition());
 
+        String sqlDependentJson = "{\n"
+                + "    \"globalParams\": [\n"
+                + "        \n"
+                + "    ],\n"
+                + "    \"tasks\": [\n"
+                + "        {\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"
+                + "        {\n"
+                + "            \"type\": \"DEPENDENT\",\n"
+                + "            \"id\": \"tasks-33787\",\n"
+                + "            \"name\": \"dependent\",\n"
+                + "            \"params\": {\n"
+                + "                \n"
+                + "            },\n"
+                + "            \"description\": \"\",\n"
+                + "            \"runFlag\": \"NORMAL\",\n"
+                + "            \"dependence\": {\n"
+                + "                \"relation\": \"AND\",\n"
+                + "                \"dependTaskList\": [\n"
+                + "                    {\n"
+                + "                        \"relation\": \"AND\",\n"
+                + "                        \"dependItemList\": [\n"
+                + "                            {\n"
+                + "                                \"projectId\": 2,\n"
+                + "                                \"definitionId\": 46,\n"
+                + "                                \"depTasks\": \"ALL\",\n"
+                + "                                \"cycle\": \"day\",\n"
+                + "                                \"dateValue\": \"today\"\n"
+                + "                            }\n"
+                + "                        ]\n"
+                + "                    }\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"
+                + "                \n"
+                + "            ]\n"
+                + "        }\n"
+                + "    ],\n"
+                + "    \"tenantId\": 1,\n"
+                + "    \"timeout\": 0\n"
+                + "}";
         Map<String, Object> updateResult = processDefinitionService.updateProcessDefinition(loginUser, projectName, 1, "test",
                 sqlDependentJson, "", "", "");
 
         Assert.assertEquals(Status.UPDATE_PROCESS_DEFINITION_ERROR, updateResult.get(Constants.STATUS));
     }
 
+    @Test
+    public void testBatchExportProcessDefinitionByIds() {
+        processDefinitionService.batchExportProcessDefinitionByIds(
+                null, null, null, null);
+
+        User loginUser = new User();
+        loginUser.setId(1);
+        loginUser.setUserType(UserType.ADMIN_USER);
+
+        String projectName = "project_test1";
+        Project project = getProject(projectName);
+
+        Map<String, Object> result = new HashMap<>();
+        putMsg(result, Status.PROJECT_NOT_FOUNT);
+        Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject(projectName));
+        Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result);
+
+        processDefinitionService.batchExportProcessDefinitionByIds(
+                loginUser, projectName, "1", null);
+    }
+
     /**
      * get mock datasource
      *
@@ -715,7 +1021,7 @@ public class ProcessDefinitionServiceTest {
      */
     private Project getProjectById(int projectId) {
         Project project = new Project();
-        project.setId(1);
+        project.setId(projectId);
         project.setName("project_test2");
         project.setUserId(1);
         return project;