add unit test in UserMapper and WorkerGroupMapper (#907)

* rename from DatasourceUserMapper to DataSourceUserMapper

* add unit test in UserMapper and WorkerGroupMapper

escheduler-dao/src/main/java/cn/escheduler/dao/entity/Tenant.java

@@ -16,9 +16,6 @@
  */
 package cn.escheduler.dao.entity;
 
-import cn.escheduler.common.enums.AlertStatus;
-import cn.escheduler.common.enums.AlertType;
-import cn.escheduler.common.enums.ShowType;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
@@ -26,8 +23,6 @@ import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 
 import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
 
 /**
  * tenant
@@ -68,10 +63,10 @@ public class Tenant {
     @TableField(exist = false)
     private String queueName;
 
-
     /**
      * queue
      */
+    @TableField(exist = false)
     private String queue;
 
     /**

escheduler-dao/src/main/resources/cn.escheduler.dao.mapper/UserMapper.xml

@@ -16,25 +16,24 @@
     </select>
 
     <select id="queryUserPaging" resultType="cn.escheduler.dao.entity.User">
-        select u.*,t.tenant_name,
+        select u.id,u.user_name,u.user_password,u.user_type,u.email,u.phone,u.tenant_id,u.create_time,
+        u.update_time,t.tenant_name,
         case when u.queue  <![CDATA[ <> ]]> '' then u.queue else q.queue_name end as queue, q.queue_name
         from t_escheduler_user u
         left join t_escheduler_tenant t on u.tenant_id=t.id
-        left join t_scheduler_queue on t.queue_id = q.id
+        left join t_escheduler_queue q on t.queue_id = q.id
         where 1=1
         <if test="userName!=null and userName != ''" >
-             and u.user_name like concat ('%', #{userName}, '%');
+             and u.user_name like concat ('%', #{userName}, '%')
         </if>
         order by u.update_time desc
     </select>
 
     <select id="queryDetailsById" resultType="cn.escheduler.dao.entity.User">
-        select u.*, t.tenant_name," +
-        "case when u.queue <![CDATA[ <> ]]>  '' then u.queue else q.queue_name end as queue_name");
-
-        FROM(TABLE_NAME + " u,t_escheduler_tenant t,t_escheduler_queue q");
-
-        WHERE("u.tenant_id = t.id and t.queue_id = q.id and u.id = #{userId})
+        select u.*, t.tenant_name,
+        case when u.queue <![CDATA[ <> ]]>  '' then u.queue else q.queue_name end as queue_name
+        from t_escheduler_user u,t_escheduler_tenant t,t_escheduler_queue q
+        WHERE u.tenant_id = t.id and t.queue_id = q.id and u.id = #{userId}
     </select>
 
     <select id="queryUserListByAlertGroupId" resultType="cn.escheduler.dao.entity.User">

escheduler-dao/src/test/java/cn/escheduler/dao/mapper/UserMapperTest.java

@@ -16,12 +16,13 @@
  */
 package cn.escheduler.dao.mapper;
 
+import cn.escheduler.common.enums.AlertType;
 import cn.escheduler.common.enums.UserType;
-import cn.escheduler.dao.datasource.ConnectionFactory;
-import cn.escheduler.dao.entity.User;
-import com.baomidou.mybatisplus.annotation.TableField;
+import cn.escheduler.common.utils.DateUtils;
+import cn.escheduler.dao.entity.*;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import org.junit.Assert;
-import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -34,13 +35,29 @@ import java.util.List;
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class UserMapperTest {
+    @Autowired
+    private UserMapper userMapper;
 
+    @Autowired
+    AlertGroupMapper alertGroupMapper;
 
     @Autowired
-    private UserMapper userMapper;
+    private UserAlertGroupMapper userAlertGroupMapper;
 
-    @Test
-    public void testInsert(){
+    @Autowired
+    AccessTokenMapper accessTokenMapper;
+
+    @Autowired
+    TenantMapper tenantMapper;
+
+    @Autowired
+    QueueMapper queueMapper;
+
+    /**
+     * insert one user
+     * @return
+     */
+    private User insertOne(){
         User user = new User();
         user.setUserName("user1");
         user.setUserPassword("1");
@@ -49,76 +66,261 @@ public class UserMapperTest {
         user.setCreateTime(new Date());
         user.setTenantId(1);
         user.setUpdateTime(new Date());
-        int res = userMapper.insert(user);
-        Assert.assertEquals(res,1);
+        userMapper.insert(user);
+        return user;
     }
 
+    /**
+     * insert one user
+     * @param tenant
+     * @return
+     */
+    private User insertOne(Tenant tenant){
+        User user = new User();
+        user.setUserName("user1");
+        user.setUserPassword("1");
+        user.setEmail("xx@123.com");
+        user.setUserType(UserType.GENERAL_USER);
+        user.setCreateTime(new Date());
+        user.setTenantId(tenant.getId());
+        user.setUpdateTime(new Date());
+        userMapper.insert(user);
+        return user;
+    }
 
-    @Test
-    public void testQueryAllGeneralUser() {
-        List<User> users = userMapper.queryAllGeneralUser();
-        System.out.println(users.size());
-        List<User> user1 = userMapper.selectList(null);
-        System.out.println(user1.size());
+    /**
+     * insert one user
+     * @param queue
+     * @param tenant
+     * @return
+     */
+    private User insertOne(Queue queue,Tenant tenant){
+        User user = new User();
+        user.setUserName("user1");
+        user.setUserPassword("1");
+        user.setEmail("xx@123.com");
+        user.setUserType(UserType.GENERAL_USER);
+        user.setCreateTime(new Date());
+        user.setTenantId(tenant.getId());
+        user.setQueue(queue.getQueueName());
+        user.setUpdateTime(new Date());
+        userMapper.insert(user);
+        return user;
     }
 
-    @Test
-    public void testQueryByUserNameAccurately() {
+    /**
+     * insert one AlertGroup
+     * @return
+     */
+    private AlertGroup insertOneAlertGroup(){
+        //insertOne
+        AlertGroup alertGroup = new AlertGroup();
+        alertGroup.setGroupName("alert group 1");
+        alertGroup.setDescription("alert test1");
+        alertGroup.setGroupType(AlertType.EMAIL);
+
+        alertGroup.setCreateTime(new Date());
+        alertGroup.setUpdateTime(new Date());
+        alertGroupMapper.insert(alertGroup);
+        return alertGroup;
     }
 
-    @Test
-    public void testQueryUserByNamePassword() {
+    /**
+     * insert one UserAlertGroup
+     * @param user
+     * @param alertGroup
+     * @return
+     */
+    private UserAlertGroup insertOneUserAlertGroup(User user,AlertGroup alertGroup){
+        UserAlertGroup userAlertGroup = new UserAlertGroup();
+        userAlertGroup.setAlertgroupName(alertGroup.getGroupName());
+        userAlertGroup.setAlertgroupId(alertGroup.getId());
+        userAlertGroup.setUserId(user.getId());
+        userAlertGroup.setCreateTime(new Date());
+        userAlertGroup.setUpdateTime(new Date());
+        userAlertGroupMapper.insert(userAlertGroup);
+        return userAlertGroup;
     }
 
-    @Test
-    public void testQueryUserPaging() {
+    /**
+     * insert one AccessToken
+     * @param user
+     * @return
+     */
+    private AccessToken insertOneAccessToken(User user){
+        //insertOne
+        AccessToken accessToken = new AccessToken();
+        accessToken.setUserId(user.getId());
+        accessToken.setToken("secrettoken");
+        accessToken.setCreateTime(new Date());
+        accessToken.setUpdateTime(new Date());
+        accessToken.setExpireTime(DateUtils.getSomeHourOfDay(new Date(),-1));
+        accessTokenMapper.insert(accessToken);
+        return accessToken;
     }
 
-    @Test
-    public void testGetDetailsById() {
+    /**
+     * insert one Tenant
+     * @return
+     */
+    private Tenant insertOneTenant(){
+        Tenant tenant = new Tenant();
+        tenant.setTenantCode("dolphin");
+        tenant.setTenantName("dolphin test");
+        tenant.setDescription("dolphin user use");
+        tenant.setQueue("1");
+        tenant.setCreateTime(new Date());
+        tenant.setUpdateTime(new Date());
+        tenantMapper.insert(tenant);
+        return tenant;
+    }
+
+    /**
+     * insert one Queue
+     * @return
+     */
+    private Queue insertOneQueue(){
+        Queue queue = new Queue();
+        queue.setQueue("dolphin");
+        queue.setQueueName("dolphin queue");
+        queue.setCreateTime(new Date());
+        queue.setUpdateTime(new Date());
+        queueMapper.insert(queue);
+        return queue;
     }
 
     @Test
-    public void testQueryUserListByAlertGroupId() {
+    public void testUpdate(){
+        //insertOne
+        User user = insertOne();
+        //update
+        user.setEmail("xx-update@126.com");
+        user.setUserName("user1_update");
+        user.setUserType(UserType.ADMIN_USER);
+        int update = userMapper.updateById(user);
+        Assert.assertEquals(update, 1);
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryTenantCodeByUserId() {
+    public void testDelete(){
+        //insertOne
+        User user = insertOne();
+        //delete
+        int delete = userMapper.deleteById(user.getId());
+        Assert.assertEquals(delete, 1);
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryUserByToken() {
+    public void testQuery() {
+        //insertOne
+        User user = insertOne();
+        //query
+        List<User> userList = userMapper.selectList(null);
+        Assert.assertNotEquals(userList.size(), 0);
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryAllGeneralUser1() {
+    public void testQueryAllGeneralUser() {
+        //insertOne
+        User user = insertOne();
+        //queryAllGeneralUser
+        List<User> userList = userMapper.queryAllGeneralUser();
+        Assert.assertNotEquals(userList.size(), 0);
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryByUserNameAccurately1() {
+    public void testQueryByUserNameAccurately() {
+        //insertOne
+        User user = insertOne();
+        //queryByUserNameAccurately
+        User queryUser = userMapper.queryByUserNameAccurately(user.getUserName());
+        Assert.assertEquals(queryUser.getUserName(), user.getUserName());
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryUserByNamePassword1() {
+    public void testQueryUserByNamePassword() {
+        //insertOne
+        User user = insertOne();
+        //queryUserByNamePassword
+        User queryUser = userMapper.queryUserByNamePassword(user.getUserName(),user.getUserPassword());
+        Assert.assertEquals(queryUser.getUserName(),user.getUserName());
+        Assert.assertEquals(queryUser.getUserPassword(),user.getUserPassword());
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryUserPaging1() {
+    public void testQueryUserPaging() {
+        //insertOneQueue
+        Queue queue = insertOneQueue();
+        //insertOneTenant
+        Tenant tenant = insertOneTenant();
+        //insertOne
+        User user = insertOne(queue,tenant);
+        //queryUserPaging
+        Page<User> page = new Page(1,3);
+        IPage<User> userIPage = userMapper.queryUserPaging(page, user.getUserName());
+        Assert.assertNotEquals(userIPage.getTotal(), 0);
+        queueMapper.deleteById(queue.getId());
+        tenantMapper.deleteById(tenant.getId());
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testGetDetailsById1() {
+    public void testQueryDetailsById() {
+        //insertOne
+        User user = insertOne();
+        //queryDetailsById
+        User queryUser = userMapper.queryDetailsById(user.getId());
+        Assert.assertEquals(queryUser,user);
+        userMapper.deleteById(user.getId());
     }
 
     @Test
-    public void testQueryUserListByAlertGroupId1() {
+    public void testQueryUserListByAlertGroupId() {
+        //insertOne
+        User user = insertOne();
+        //insertOneAlertGroup
+        AlertGroup alertGroup = insertOneAlertGroup();
+        //insertOneUserAlertGroup
+        UserAlertGroup userAlertGroup = insertOneUserAlertGroup(user, alertGroup);
+        //queryUserListByAlertGroupId
+        List<User> userList = userMapper.queryUserListByAlertGroupId(userAlertGroup.getAlertgroupId());
+        Assert.assertNotEquals(userList.size(), 0);
+        userMapper.deleteById(user.getId());
+        alertGroupMapper.deleteById(alertGroup.getId());
+        userAlertGroupMapper.deleteById(userAlertGroup.getAlertgroupId());
+
     }
 
     @Test
-    public void testQueryTenantCodeByUserId1() {
+    public void testQueryTenantCodeByUserId() {
+        //insertOneTenant
+        Tenant tenant = insertOneTenant();
+        //insertOne
+        User user = insertOne(tenant);
+        //queryTenantCodeByUserId
+        User queryUser = userMapper.queryTenantCodeByUserId(user.getId());
+        Assert.assertEquals(queryUser,user);
+        userMapper.deleteById(user.getId());
+        tenantMapper.deleteById(tenant.getId());
     }
 
     @Test
-    public void testQueryUserByToken1() {
+    public void testQueryUserByToken() {
+        //insertOne
+        User user = insertOne();
+        //insertOneAccessToken
+        AccessToken accessToken = insertOneAccessToken(user);
+        //queryUserByToken
+        User userToken = userMapper.queryUserByToken(accessToken.getToken());
+        Assert.assertEquals(userToken,user);
+        userMapper.deleteById(user.getId());
+        accessTokenMapper.deleteById(accessToken.getId());
+
     }
 }

escheduler-dao/src/test/java/cn/escheduler/dao/mapper/WorkerGroupMapperTest.java

@@ -17,24 +17,97 @@
 package cn.escheduler.dao.mapper;
 
 
+import cn.escheduler.dao.entity.WorkerGroup;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.test.context.junit4.SpringRunner;
 
+import java.util.Date;
+import java.util.List;
+
 @RunWith(SpringRunner.class)
 @SpringBootTest
 public class WorkerGroupMapperTest {
+    @Autowired
+    WorkerGroupMapper workerGroupMapper;
+
+    private WorkerGroup insertOne(){
+        //insertOne
+        WorkerGroup workerGroup = new WorkerGroup();
+
+        String name = "workerGroup3";
+        workerGroup.setName(name);
+        workerGroup.setIpList("192.168.220.154,192.168.220.188");
+        workerGroup.setCreateTime(new Date());
+        workerGroup.setUpdateTime(new Date());
+        workerGroupMapper.insert(workerGroup);
+        return workerGroup;
+    }
+
+
+    @Test
+    public void testUpdate(){
+        //insertOne
+        WorkerGroup workerGroup = insertOne();
+        //update
+        workerGroup.setName("workerGroup11");
+        int update = workerGroupMapper.updateById(workerGroup);
+        Assert.assertEquals(update, 1);
+        workerGroupMapper.deleteById(workerGroup.getId());
+    }
+
+    @Test
+    public void testDelete(){
+        //insertOne
+        WorkerGroup workerGroup = insertOne();
+        //delete
+        int delete = workerGroupMapper.deleteById(workerGroup.getId());
+        Assert.assertEquals(delete, 1);
+    }
+
+    @Test
+    public void testQuery() {
+        //insertOne
+        WorkerGroup workerGroup = insertOne();
+        //query
+        List<WorkerGroup> workerGroupList = workerGroupMapper.selectList(null);
+        Assert.assertNotEquals(workerGroupList.size(), 0);
+        workerGroupMapper.deleteById(workerGroup.getId());
+    }
 
     @Test
     public void testQueryAllWorkerGroup() {
+        //insertOne
+        WorkerGroup workerGroup = insertOne();
+        //queryAllWorkerGroup
+        List<WorkerGroup> workerGroupList = workerGroupMapper.queryAllWorkerGroup();
+        Assert.assertNotEquals(workerGroupList.size(), 0);
+        workerGroupMapper.deleteById(workerGroup.getId());
     }
 
     @Test
     public void testQueryWorkerGroupByName() {
+        //insertOne
+        WorkerGroup workerGroup = insertOne();
+        //queryWorkerGroupByName
+        List<WorkerGroup> workerGroupList = workerGroupMapper.queryWorkerGroupByName(workerGroup.getName());
+        Assert.assertNotEquals(workerGroupList.size(), 0);
+        workerGroupMapper.deleteById(workerGroup.getId());
     }
 
     @Test
     public void testQueryListPaging() {
+        //insertOne
+        WorkerGroup workerGroup = insertOne();
+        //queryListPaging
+        Page<WorkerGroup> page = new Page(1,3);
+        IPage<WorkerGroup> workerGroupIPage = workerGroupMapper.queryListPaging(page, workerGroup.getName());
+        Assert.assertNotEquals(workerGroupIPage.getTotal(), 0);
+        workerGroupMapper.deleteById(workerGroup.getId());
     }
 }