From bd4b2f85a9ef6ac125a18ee6e2eb73ee441c10db Mon Sep 17 00:00:00 2001 From: Simon <3656562@qq.com> Date: Sat, 6 Mar 2021 10:56:49 +0800 Subject: [PATCH] [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 --- .../impl/ProcessInstanceServiceImpl.java | 2 +- .../api/service/DataAnalysisServiceTest.java | 27 +- .../service/ProcessDefinitionServiceTest.java | 81 +---- .../service/ProcessInstanceServiceTest.java | 31 ++ .../ProcessTaskRelationServiceImplTest.java | 107 +++++++ .../api/service/ProjectServiceTest.java | 1 + .../TaskDefinitionServiceImplTest.java | 298 ++++++++++++++++++ .../api/service/TaskInstanceServiceTest.java | 2 +- pom.xml | 4 +- 9 files changed, 466 insertions(+), 87 deletions(-) create mode 100644 dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationServiceImplTest.java create mode 100644 dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskDefinitionServiceImplTest.java diff --git a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessInstanceServiceImpl.java b/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessInstanceServiceImpl.java index ca0bc8ccee..a83900e322 100644 --- a/dolphinscheduler-api/src/main/java/org/apache/dolphinscheduler/api/service/impl/ProcessInstanceServiceImpl.java +++ b/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); } -} +} \ No newline at end of file diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/DataAnalysisServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/DataAnalysisServiceTest.java index b1f6752fb9..d152fa3536 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/DataAnalysisServiceTest.java +++ b/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 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 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; + } } \ No newline at end of file diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionServiceTest.java index fbe0f51775..5f87999fcc 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessDefinitionServiceTest.java +++ b/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 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 processDefinitionList = new ArrayList<>(); processDefinitionList.add(processDefinition); - Project project = projectMapper.selectById(projectId); - Mockito.when(processDefineMapper.queryAllDefinitionList(project.getCode())).thenReturn(processDefinitionList); + Project test = getProject("test"); + Mockito.when(projectMapper.selectById(projectId)).thenReturn(test); + Mockito.when(processDefineMapper.queryAllDefinitionList(test.getCode())).thenReturn(processDefinitionList); Map 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 * diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessInstanceServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessInstanceServiceTest.java index 27650e37f8..ea8f3c4faf 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessInstanceServiceTest.java +++ b/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 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 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 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 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; diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationServiceImplTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProcessTaskRelationServiceImplTest.java new file mode 100644 index 0000000000..b1b20a7e5e --- /dev/null +++ b/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 result = new HashMap<>(); + putMsg(result, Status.SUCCESS, projectName); + + //project check auth fail + Mockito.when(projectService.checkProjectAndAuth(loginUser, project, projectName)).thenReturn(result); + + Map relation = processTaskRelationService + .queryProcessTaskRelation(loginUser, projectName, 11L); + + Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS)); + } + + private void putMsg(Map 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; + } + +} diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProjectServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProjectServiceTest.java index 74156f7b17..857c52af79 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/ProjectServiceTest.java +++ b/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); diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskDefinitionServiceImplTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskDefinitionServiceImplTest.java new file mode 100644 index 0000000000..bd2961411c --- /dev/null +++ b/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 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 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 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 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 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 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 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 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 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 relation = taskDefinitionService + .switchVersion(loginUser, projectName, taskCode, version); + + Assert.assertEquals(Status.SUCCESS, relation.get(Constants.STATUS)); + } + + private void putMsg(Map 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; + } + +} diff --git a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskInstanceServiceTest.java b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskInstanceServiceTest.java index 62b0b73da3..d698486517 100644 --- a/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskInstanceServiceTest.java +++ b/dolphinscheduler-api/src/test/java/org/apache/dolphinscheduler/api/service/TaskInstanceServiceTest.java @@ -267,4 +267,4 @@ public class TaskInstanceServiceTest { Map successRes = taskInstanceService.forceTaskSuccess(user, projectName, taskId); Assert.assertEquals(Status.SUCCESS, successRes.get(Constants.STATUS)); } -} +} \ No newline at end of file diff --git a/pom.xml b/pom.xml index 2829dca7ac..59703ff724 100644 --- a/pom.xml +++ b/pom.xml @@ -821,7 +821,8 @@ **/api/service/LoggerServiceTest.java **/api/service/MonitorServiceTest.java **/api/service/ProcessDefinitionServiceTest.java - **/api/service/ProcessDefinitionVersionServiceTest.java + **/api/service/ProcessTaskRelationServiceImplTest.java + **/api/service/TaskDefinitionServiceImplTest.java **/api/service/ProcessInstanceServiceTest.java **/api/service/ProjectServiceTest.java **/api/service/QueueServiceTest.java @@ -970,7 +971,6 @@ **/dao/mapper/DataSourceUserMapperTest.java **/dao/mapper/ProcessDefinitionMapperTest.java - **/dao/mapper/ProcessDefinitionVersionMapperTest.java **/dao/mapper/ProcessInstanceMapMapperTest.java **/dao/mapper/ProcessInstanceMapperTest.java **/dao/mapper/ProjectMapperTest.java