| |
| /* |
| * 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 static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.PROJECT; |
| import static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.PROJECT_CREATE; |
| import static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.PROJECT_DELETE; |
| import static org.apache.dolphinscheduler.api.constants.ApiFuncIdentificationConstant.PROJECT_UPDATE; |
| import static org.mockito.ArgumentMatchers.any; |
| import static org.mockito.ArgumentMatchers.eq; |
| |
| import org.apache.dolphinscheduler.api.enums.Status; |
| import org.apache.dolphinscheduler.api.permission.ResourcePermissionCheckService; |
| import org.apache.dolphinscheduler.api.service.impl.BaseServiceImpl; |
| import org.apache.dolphinscheduler.api.service.impl.ProjectServiceImpl; |
| import org.apache.dolphinscheduler.api.utils.PageInfo; |
| import org.apache.dolphinscheduler.api.utils.Result; |
| import org.apache.dolphinscheduler.common.constants.Constants; |
| import org.apache.dolphinscheduler.common.enums.AuthorizationType; |
| import org.apache.dolphinscheduler.common.enums.UserType; |
| import org.apache.dolphinscheduler.dao.entity.ProcessDefinition; |
| 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.ProjectMapper; |
| import org.apache.dolphinscheduler.dao.mapper.ProjectUserMapper; |
| import org.apache.dolphinscheduler.dao.mapper.UserMapper; |
| |
| import org.apache.commons.collections4.CollectionUtils; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.junit.jupiter.api.Assertions; |
| import org.junit.jupiter.api.Test; |
| import org.junit.jupiter.api.extension.ExtendWith; |
| import org.mockito.InjectMocks; |
| import org.mockito.Mock; |
| import org.mockito.Mockito; |
| import org.mockito.junit.jupiter.MockitoExtension; |
| import org.mockito.junit.jupiter.MockitoSettings; |
| import org.mockito.quality.Strictness; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.baomidou.mybatisplus.core.metadata.IPage; |
| import com.baomidou.mybatisplus.extension.plugins.pagination.Page; |
| |
| /** |
| * project service test |
| **/ |
| @ExtendWith(MockitoExtension.class) |
| @MockitoSettings(strictness = Strictness.LENIENT) |
| public class ProjectServiceTest { |
| |
| private static final Logger logger = LoggerFactory.getLogger(ProjectServiceTest.class); |
| private static final Logger baseServiceLogger = LoggerFactory.getLogger(BaseServiceImpl.class); |
| private static final Logger projectLogger = LoggerFactory.getLogger(ProjectServiceImpl.class); |
| @InjectMocks |
| private ProjectServiceImpl projectService; |
| |
| @Mock |
| private ProjectMapper projectMapper; |
| |
| @Mock |
| private ProjectUserMapper projectUserMapper; |
| |
| @Mock |
| private ProcessDefinitionMapper processDefinitionMapper; |
| |
| @Mock |
| private UserMapper userMapper; |
| |
| @Mock |
| private ResourcePermissionCheckService resourcePermissionCheckService; |
| |
| @Mock |
| private TaskGroupService taskGroupService; |
| |
| private String projectName = "ProjectServiceTest"; |
| |
| private String userName = "ProjectServiceTest"; |
| |
| @Test |
| public void testCreateProject() { |
| User loginUser = getLoginUser(); |
| Mockito.when(resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, 1, |
| PROJECT_CREATE, baseServiceLogger)).thenReturn(true); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, null, 1, |
| baseServiceLogger)).thenReturn(true); |
| |
| // REQUEST_PARAMS_NOT_VALID_ERROR |
| Result result = projectService.createProject(loginUser, projectName, getDesc()); |
| logger.info(result.toString()); |
| Assertions.assertEquals(Status.REQUEST_PARAMS_NOT_VALID_ERROR.getCode(), 10001); |
| |
| // PROJECT_ALREADY_EXISTS |
| Mockito.when(projectMapper.queryByName(projectName)).thenReturn(getProject()); |
| result = projectService.createProject(loginUser, projectName, projectName); |
| logger.info(result.toString()); |
| Assertions.assertEquals(Status.PROJECT_ALREADY_EXISTS.getCode(), result.getCode().intValue()); |
| |
| // success |
| Mockito.when(projectMapper.insert(Mockito.any(Project.class))).thenReturn(1); |
| result = projectService.createProject(loginUser, "test", "test"); |
| logger.info(result.toString()); |
| Assertions.assertEquals(Status.SUCCESS.getCode(), result.getCode().intValue()); |
| |
| } |
| |
| @Test |
| public void testCheckProjectAndAuth() { |
| long projectCode = 1L; |
| User loginUser = getLoginUser(); |
| |
| // PROJECT_NOT_EXIST |
| Map<String, Object> result = projectService.checkProjectAndAuth(loginUser, null, projectCode, PROJECT); |
| logger.info(result.toString()); |
| Assertions.assertEquals(Status.PROJECT_NOT_EXIST, result.get(Constants.STATUS)); |
| |
| // USER_NO_OPERATION_PROJECT_PERM |
| Project project = getProject(); |
| project.setUserId(2); |
| result = projectService.checkProjectAndAuth(loginUser, project, projectCode, PROJECT); |
| logger.info(result.toString()); |
| Assertions.assertEquals(Status.USER_NO_OPERATION_PROJECT_PERM, result.get(Constants.STATUS)); |
| |
| // success |
| project.setUserId(1); |
| loginUser.setUserType(UserType.ADMIN_USER); |
| Mockito.when(resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, |
| project.getUserId(), PROJECT, baseServiceLogger)).thenReturn(true); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, |
| new Object[]{project.getId()}, |
| 0, baseServiceLogger)).thenReturn(true); |
| result = projectService.checkProjectAndAuth(loginUser, project, projectCode, PROJECT); |
| logger.info(result.toString()); |
| Assertions.assertEquals(Status.SUCCESS, result.get(Constants.STATUS)); |
| } |
| |
| @Test |
| public void testHasProjectAndPerm() { |
| User loginUser = getLoginUser(); |
| Project project = getProject(); |
| Map<String, Object> result = new HashMap<>(); |
| // not exist user |
| User tempUser = new User(); |
| tempUser.setId(Integer.MAX_VALUE); |
| tempUser.setUserType(UserType.GENERAL_USER); |
| Mockito.when(resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, |
| tempUser.getId(), null, baseServiceLogger)).thenReturn(true); |
| boolean checkResult = projectService.hasProjectAndPerm(tempUser, project, result, null); |
| logger.info(result.toString()); |
| Assertions.assertFalse(checkResult); |
| |
| // success |
| result = new HashMap<>(); |
| project.setUserId(1); |
| Mockito.when(resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, |
| loginUser.getId(), null, baseServiceLogger)).thenReturn(true); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, |
| new Object[]{project.getId()}, |
| loginUser.getId(), baseServiceLogger)).thenReturn(true); |
| checkResult = projectService.hasProjectAndPerm(loginUser, project, result, null); |
| logger.info(result.toString()); |
| Assertions.assertTrue(checkResult); |
| } |
| |
| @Test |
| public void testQueryProjectWithAuthorizedLevelListPaging() { |
| IPage<Project> page = new Page<>(1, 10); |
| page.setTotal(1L); |
| page.setRecords(getList()); |
| |
| User loginUser = getLoginUser(); |
| Integer pageSize = 10; |
| Integer pageNo = 1; |
| String searchVal = "testVal"; |
| Result result = new Result(); |
| Mockito.when(projectMapper.queryProjectListPaging(any(Page.class), Mockito.anyList(), eq(searchVal))) |
| .thenReturn(page); |
| |
| Set<Integer> allProjectIds = new HashSet(); |
| allProjectIds.add(1); |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(allProjectIds); |
| |
| // SUCCESS |
| result = projectService.queryProjectWithAuthorizedLevelListPaging(loginUser.getId(), loginUser, pageSize, |
| pageNo, searchVal); |
| logger.info(result.toString()); |
| PageInfo<Project> pageInfo = (PageInfo<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(pageInfo.getTotalList())); |
| } |
| |
| @Test |
| public void testHasProjectAndWritePerm() { |
| User loginUser = getLoginUser(); |
| Project project = getProject(); |
| Map<String, Object> result = new HashMap<>(); |
| // not exist user |
| User tempUser = new User(); |
| tempUser.setId(Integer.MAX_VALUE); |
| tempUser.setUserType(UserType.GENERAL_USER); |
| Mockito.when(resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, |
| tempUser.getId(), null, baseServiceLogger)).thenReturn(true); |
| boolean checkResult = projectService.hasProjectAndWritePerm(tempUser, project, result); |
| logger.info(result.toString()); |
| Assertions.assertFalse(checkResult); |
| |
| // success |
| result = new HashMap<>(); |
| project.setUserId(1); |
| loginUser.setUserType(UserType.ADMIN_USER); |
| Mockito.when(resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, |
| loginUser.getId(), null, baseServiceLogger)).thenReturn(true); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, |
| new Object[]{project.getId()}, |
| loginUser.getId(), baseServiceLogger)).thenReturn(true); |
| checkResult = projectService.hasProjectAndWritePerm(loginUser, project, result); |
| logger.info(result.toString()); |
| Assertions.assertTrue(checkResult); |
| } |
| |
| @Test |
| public void testDeleteProject() { |
| User loginUser = getLoginUser(); |
| Mockito.when(projectMapper.queryByCode(1L)).thenReturn(getProject()); |
| |
| // PROJECT_NOT_FOUND |
| Result result = projectService.deleteProject(loginUser, 11L); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.PROJECT_NOT_FOUND.getCode() == result.getCode()); |
| loginUser.setId(2); |
| |
| // USER_NO_OPERATION_PROJECT_PERM |
| result = projectService.deleteProject(loginUser, 1L); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.USER_NO_WRITE_PROJECT_PERM.getCode() == result.getCode()); |
| |
| // DELETE_PROJECT_ERROR_DEFINES_NOT_NULL |
| Mockito.when(processDefinitionMapper.queryAllDefinitionList(1L)).thenReturn(getProcessDefinitions()); |
| loginUser.setUserType(UserType.ADMIN_USER); |
| loginUser.setId(1); |
| Mockito.when( |
| resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, new Object[]{1}, 0, |
| baseServiceLogger)) |
| .thenReturn(true); |
| Mockito.when( |
| resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, loginUser.getId(), |
| PROJECT_DELETE, baseServiceLogger)) |
| .thenReturn(true); |
| result = projectService.deleteProject(loginUser, 1L); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.DELETE_PROJECT_ERROR_DEFINES_NOT_NULL.getCode() == result.getCode()); |
| |
| // success |
| Mockito.when(projectMapper.deleteById(1)).thenReturn(1); |
| Mockito.when(processDefinitionMapper.queryAllDefinitionList(1L)).thenReturn(new ArrayList<>()); |
| result = projectService.deleteProject(loginUser, 1L); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.SUCCESS.getCode() == result.getCode()); |
| } |
| |
| @Test |
| public void testUpdate() { |
| |
| User loginUser = getLoginUser(); |
| loginUser.setId(1); |
| Project project = getProject(); |
| project.setCode(2L); |
| Mockito.when(projectMapper.queryByName(projectName)).thenReturn(project); |
| Mockito.when(projectMapper.queryByCode(2L)).thenReturn(getProject()); |
| // PROJECT_NOT_FOUND |
| Result result = projectService.update(loginUser, 1L, projectName, "desc"); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.PROJECT_NOT_FOUND.getCode() == result.getCode()); |
| |
| // PROJECT_ALREADY_EXISTS |
| Mockito.when( |
| resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, loginUser.getId(), |
| PROJECT_UPDATE, baseServiceLogger)) |
| .thenReturn(true); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, new Object[]{1}, |
| loginUser.getId(), |
| baseServiceLogger)).thenReturn(true); |
| result = projectService.update(loginUser, 2L, projectName, "desc"); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.PROJECT_ALREADY_EXISTS.getCode() == result.getCode()); |
| |
| // USER_NOT_EXIST |
| Mockito.when(userMapper.selectById(Mockito.any())).thenReturn(null); |
| result = projectService.update(loginUser, 2L, "test", "desc"); |
| Assertions.assertTrue(Status.USER_NOT_EXIST.getCode() == result.getCode()); |
| |
| // success |
| Mockito.when(userMapper.selectById(Mockito.any())).thenReturn(new User()); |
| project.setUserId(1); |
| Mockito.when(projectMapper.updateById(Mockito.any(Project.class))).thenReturn(1); |
| result = projectService.update(loginUser, 2L, "test", "desc"); |
| logger.info(result.toString()); |
| Assertions.assertTrue(Status.SUCCESS.getCode() == result.getCode()); |
| |
| } |
| |
| @Test |
| public void testQueryAuthorizedProject() { |
| Mockito.when(projectMapper.queryAuthedProjectListByUserId(2)).thenReturn(getList()); |
| |
| User loginUser = getLoginUser(); |
| |
| // test admin user |
| loginUser.setUserType(UserType.ADMIN_USER); |
| Result result = projectService.queryAuthorizedProject(loginUser, 2); |
| logger.info(result.toString()); |
| List<Project> projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| // test non-admin user |
| loginUser.setUserType(UserType.GENERAL_USER); |
| loginUser.setId(3); |
| result = projectService.queryAuthorizedProject(loginUser, 2); |
| projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| } |
| |
| @Test |
| public void testQueryAuthorizedUser() { |
| final User loginUser = this.getLoginUser(); |
| |
| // Failure 1: PROJECT_NOT_FOUND |
| Result result = this.projectService.queryAuthorizedUser(loginUser, 3682329499136L); |
| logger.info("FAILURE 1: {}", result.toString()); |
| Assertions.assertTrue(Status.PROJECT_NOT_FOUND.getCode() == result.getCode()); |
| |
| // Failure 2: USER_NO_OPERATION_PROJECT_PERM |
| Mockito.when(this.projectMapper.queryByCode(Mockito.anyLong())).thenReturn(this.getProject()); |
| result = this.projectService.queryAuthorizedUser(loginUser, 3682329499136L); |
| logger.info("FAILURE 2: {}", result.toString()); |
| Assertions.assertTrue(Status.USER_NO_OPERATION_PROJECT_PERM.getCode() == result.getCode()); |
| |
| // SUCCESS |
| loginUser.setUserType(UserType.ADMIN_USER); |
| Mockito.when( |
| resourcePermissionCheckService.operationPermissionCheck(AuthorizationType.PROJECTS, |
| loginUser.getId(), PROJECT, baseServiceLogger)) |
| .thenReturn(true); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, new Object[]{1}, |
| 0, baseServiceLogger)).thenReturn(true); |
| Mockito.when(this.userMapper.queryAuthedUserListByProjectId(1)).thenReturn(this.getUserList()); |
| result = this.projectService.queryAuthorizedUser(loginUser, 3682329499136L); |
| logger.info("SUCCESS 1: {}", result.toString()); |
| List<User> users = (List<User>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(users)); |
| |
| loginUser.setId(1); |
| loginUser.setUserType(UserType.GENERAL_USER); |
| Mockito.when(resourcePermissionCheckService.resourcePermissionCheck(AuthorizationType.PROJECTS, new Object[]{1}, |
| 1, baseServiceLogger)).thenReturn(true); |
| result = this.projectService.queryAuthorizedUser(loginUser, 3682329499136L); |
| logger.info("SUCCESS 2: {}", result.toString()); |
| users = (List<User>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(users)); |
| } |
| |
| @Test |
| public void testQueryCreatedProject() { |
| |
| User loginUser = getLoginUser(); |
| |
| Mockito.when(projectMapper.queryProjectCreatedByUser(1)).thenReturn(getList()); |
| |
| // success |
| loginUser.setUserType(UserType.ADMIN_USER); |
| Map<String, Object> result = projectService.queryProjectCreatedByUser(loginUser); |
| logger.info(result.toString()); |
| List<Project> projects = (List<Project>) result.get(Constants.DATA_LIST); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| } |
| |
| @Test |
| public void testQueryProjectCreatedAndAuthorizedByUser() { |
| Result result; |
| User loginUser = getLoginUser(); |
| Set<Integer> set = new HashSet(); |
| set.add(1); |
| |
| // not admin user |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(set); |
| Mockito.when(projectMapper.selectBatchIds(set)).thenReturn(getList()); |
| result = projectService.queryProjectCreatedAndAuthorizedByUser(loginUser); |
| List<Project> notAdminUserResult = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(notAdminUserResult)); |
| |
| // admin user |
| loginUser.setUserType(UserType.ADMIN_USER); |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(set); |
| Mockito.when(projectMapper.selectBatchIds(set)).thenReturn(getList()); |
| result = projectService.queryProjectCreatedAndAuthorizedByUser(loginUser); |
| List<Project> projects = (List<Project>) result.getData(); |
| |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| } |
| |
| @Test |
| public void testQueryAllProjectList() { |
| Mockito.when(projectMapper.queryAllProject(0)).thenReturn(getList()); |
| |
| User user = new User(); |
| user.setId(0); |
| Result result = projectService.queryAllProjectList(user); |
| logger.info(result.toString()); |
| List<Project> projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| } |
| @Test |
| public void queryAllProjectListForDependent() { |
| Mockito.when(projectMapper.queryAllProjectForDependent()).thenReturn(getList()); |
| |
| Result result = projectService.queryAllProjectListForDependent(); |
| logger.info(result.toString()); |
| List<Project> projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| } |
| |
| @Test |
| public void testQueryProjectWithAuthorizedLevel() { |
| Set<Integer> set = new HashSet(); |
| set.add(1); |
| // test admin user |
| User loginUser = new User(); |
| loginUser.setUserType(UserType.ADMIN_USER); |
| loginUser.setId(1); |
| List<Integer> list = new ArrayList<>(1); |
| list.add(1); |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(set); |
| Mockito.when(projectMapper.listAuthorizedProjects( |
| loginUser.getUserType().equals(UserType.ADMIN_USER) ? 0 : loginUser.getId(), list)) |
| .thenReturn(getList()); |
| Result result = projectService.queryProjectWithAuthorizedLevel(loginUser, 2); |
| logger.info(result.toString()); |
| List<Project> projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| // test non-admin user |
| loginUser.setId(2); |
| loginUser.setUserType(UserType.GENERAL_USER); |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(set); |
| Mockito.when(projectMapper.listAuthorizedProjects( |
| loginUser.getUserType().equals(UserType.ADMIN_USER) ? 0 : loginUser.getId(), list)) |
| .thenReturn(getList()); |
| result = projectService.queryProjectWithAuthorizedLevel(loginUser, 3); |
| logger.info(result.toString()); |
| projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| } |
| |
| @Test |
| public void testQueryUnauthorizedProject() { |
| Set<Integer> set = new HashSet(); |
| set.add(1); |
| // test admin user |
| User loginUser = new User(); |
| loginUser.setUserType(UserType.ADMIN_USER); |
| loginUser.setId(1); |
| List<Integer> list = new ArrayList<>(1); |
| list.add(1); |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(set); |
| Mockito.when(projectMapper.listAuthorizedProjects( |
| loginUser.getUserType().equals(UserType.ADMIN_USER) ? 0 : loginUser.getId(), list)) |
| .thenReturn(getList()); |
| Result result = projectService.queryUnauthorizedProject(loginUser, 2); |
| logger.info(result.toString()); |
| List<Project> projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| |
| // test non-admin user |
| loginUser.setId(2); |
| loginUser.setUserType(UserType.GENERAL_USER); |
| Mockito.when(resourcePermissionCheckService.userOwnedResourceIdsAcquisition(AuthorizationType.PROJECTS, |
| loginUser.getId(), projectLogger)).thenReturn(set); |
| Mockito.when(projectMapper.listAuthorizedProjects( |
| loginUser.getUserType().equals(UserType.ADMIN_USER) ? 0 : loginUser.getId(), list)) |
| .thenReturn(getList()); |
| result = projectService.queryUnauthorizedProject(loginUser, 3); |
| logger.info(result.toString()); |
| projects = (List<Project>) result.getData(); |
| Assertions.assertTrue(CollectionUtils.isNotEmpty(projects)); |
| } |
| |
| private Project getProject() { |
| Project project = new Project(); |
| project.setCode(1L); |
| project.setId(1); |
| project.setName(projectName); |
| project.setUserId(1); |
| return project; |
| } |
| |
| private Project getProject(int projectId) { |
| Project project = new Project(); |
| project.setId(projectId); |
| project.setCode(1L); |
| project.setName(projectName); |
| project.setUserId(1); |
| return project; |
| } |
| |
| private List<Project> getList() { |
| List<Project> list = new ArrayList<>(); |
| list.add(getProject(1)); |
| list.add(getProject(2)); |
| list.add(getProject(3)); |
| return list; |
| } |
| |
| private User getLoginUser() { |
| User loginUser = new User(); |
| loginUser.setUserType(UserType.GENERAL_USER); |
| loginUser.setUserName(userName); |
| loginUser.setId(1); |
| return loginUser; |
| } |
| |
| /** |
| * Get general user |
| * |
| * @return |
| */ |
| private User getGeneralUser() { |
| User user = new User(); |
| user.setUserType(UserType.GENERAL_USER); |
| user.setUserName("userTest0001"); |
| user.setUserPassword("userTest0001"); |
| return user; |
| } |
| |
| /** |
| * Get user list |
| * |
| * @return |
| */ |
| private List<User> getUserList() { |
| List<User> userList = new ArrayList<>(); |
| userList.add(this.getGeneralUser()); |
| return userList; |
| } |
| |
| private List<ProcessDefinition> getProcessDefinitions() { |
| List<ProcessDefinition> list = new ArrayList<>(); |
| ProcessDefinition processDefinition = new ProcessDefinition(); |
| processDefinition.setProjectCode(1L); |
| list.add(processDefinition); |
| return list; |
| } |
| |
| private String getDesc() { |
| return "projectUserMapper.deleteProjectRelation(projectId,userId)projectUserMappe" |
| + ".deleteProjectRelation(projectId,userId)projectUserMappe" |
| + "r.deleteProjectRelation(projectId,userId)projectUserMapper" |
| + ".deleteProjectRelation(projectId,userId)projectUserMapper.deleteProjectRelation(projectId,userId)"; |
| } |
| |
| } |
