1、更改es依赖maven

2、移除不相干的类

menduner/menduner-common/pom.xml

@@ -74,12 +74,6 @@
             <artifactId>citu-spring-boot-starter-excel</artifactId>
         </dependency>
 
-        <dependency>
-            <groupId>com.citu</groupId>
-            <artifactId>citu-spring-boot-starter-es</artifactId>
-            <version>${revision}</version>
-        </dependency>
-
         <!-- 监控相关 -->
         <dependency>
             <groupId>com.citu</groupId>

menduner/menduner-im-api/pom.xml

@@ -20,12 +20,6 @@
             <groupId>com.citu</groupId>
             <artifactId>menduner-common</artifactId>
             <version>${revision}</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>com.citu</groupId>
-                    <artifactId>citu-spring-boot-starter-es</artifactId>
-                </exclusion>
-            </exclusions>
         </dependency>
 
     </dependencies>

menduner/menduner-im-biz/pom.xml

@@ -32,7 +32,6 @@
         </dependency>
 
 
-
         <!-- Registry 注册中心相关 -->
         <dependency>
             <groupId>com.alibaba.cloud</groupId>

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/config/package-info.java

@@ -1,4 +1,4 @@
 /**
  * @author Rayson
  */
-package com.citu.module.menduner.system.config;
+package com.citu.module.menduner.im.config;

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/config/permission/CustomDataPermissionAutoConfiguration.java

@@ -1,40 +0,0 @@
-package com.citu.module.menduner.im.config.permission;
-
-import cn.hutool.extra.spring.SpringUtil;
-//import com.citu.module.menduner.system.api.permission.MendunerPermissionApi;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-import java.util.List;
-
-/**
- * 自定义的数据权限 AutoConfiguration
- *
- * @author Rayson
- */
-@Configuration
-//@ConditionalOnClass(LoginUser.class)
-//@ConditionalOnBean(value = CustomDataPermissionRuleCustomizer.class)
-public class CustomDataPermissionAutoConfiguration {
-
-//    @Bean
-//    public CustomDataPermissionRule customDataPermissionRule(MendunerPermissionApi permissionApi,
-//                                                             List<CustomDataPermissionRuleCustomizer> customizers) {
-//        // Cloud 专属逻辑：优先使用本地的 MendunerPermissionApi 实现类，而不是 Feign 调用
-//        // 原因：在创建租户时，租户还没创建好，导致 Feign 调用获取数据权限时，报“租户不存在”的错误
-//        try {
-//            MendunerPermissionApi permissionApiImpl = SpringUtil.getBean("mendunerPermissionApi", MendunerPermissionApi.class);
-//            if (permissionApiImpl != null) {
-//                permissionApi = permissionApiImpl;
-//            }
-//        } catch (Exception ignored) {
-//        }
-//
-//        // 创建 CustomDataPermissionRule 对象
-//        CustomDataPermissionRule rule = new CustomDataPermissionRule(permissionApi);
-//        // 补全表配置
-//        customizers.forEach(customizer -> customizer.customize(rule));
-//        return rule;
-//    }
-
-}

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/config/permission/CustomDataPermissionRule.java

@@ -1,197 +0,0 @@
-package com.citu.module.menduner.im.config.permission;
-
-import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.text.CharSequenceUtil;
-import cn.hutool.core.util.ObjectUtil;
-import cn.hutool.core.util.StrUtil;
-import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
-import com.citu.framework.common.enums.UserTypeEnum;
-import com.citu.framework.common.util.collection.CollectionUtils;
-import com.citu.framework.common.util.json.JsonUtils;
-import com.citu.framework.datapermission.core.rule.DataPermissionRule;
-import com.citu.framework.mybatis.core.dataobject.BaseDO;
-import com.citu.framework.mybatis.core.util.MyBatisUtils;
-import com.citu.framework.security.core.LoginUser;
-import com.citu.framework.security.core.util.SecurityFrameworkUtils;
-//import com.citu.module.menduner.im.api.permission.MendunerPermissionApi;
-import com.citu.module.menduner.common.util.LoginUserContext;
-import com.citu.module.system.api.permission.dto.DataPermissionRespDTO;
-import lombok.AllArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import net.sf.jsqlparser.expression.*;
-import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
-import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
-import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
-import net.sf.jsqlparser.expression.operators.relational.InExpression;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-import static com.citu.module.menduner.common.util.LoginUserContext.checkEnterprise;
-
-/**
- * @author Rayson
- * @description CustomDataPermissionRule
- * 基于自定义的 {@link DataPermissionRule} 数据权限规则实现
- * @create 2024/5/8 下午7:41
- **/
-@AllArgsConstructor
-@Slf4j
-public class CustomDataPermissionRule implements DataPermissionRule {
-
-    /**
-     * LoginUser 的 Context 缓存 Key
-     */
-    protected static final String CONTEXT_KEY = CustomDataPermissionRule.class.getSimpleName();
-
-    static final Expression EXPRESSION_NULL = new NullValue();
-    /**
-     * 基于数据的表字段配置 TODO 目前只支持一个数据权限字段，xx_id 和 user_id 不能同时配置。
-     * 如基于部门的数据编号字段是 自定义xx_id，基于店铺的数据编号字段是 shop_id，通过该配置自定义，如 group_id。
-     * <p>
-     * key：表名
-     * value：字段名
-     */
-    private final static Map<String, String> DATA_COLUMNS = new HashMap<>();
-    /**
-     * 基于用户的表字段配置
-     * 一般情况下，每个表的数据编号字段是 user_id，通过该配置自定义，如 admin_user_id。
-     * <p>
-     * key：表名
-     * value：字段名
-     */
-    private final static Map<String, String> USER_COLUMNS = new HashMap<>();
-    /**
-     * 所有表名，是 {@link #DATA_COLUMNS} 和 {@link #USER_COLUMNS} 的合集
-     */
-    private final static Set<String> TABLE_NAMES = new HashSet<>();
-
-//    private final MendunerPermissionApi permissionApi;
-
-    @Override
-    public Set<String> getTableNames() {
-        return TABLE_NAMES;
-    }
-
-    @Override
-    public Expression getExpression(String tableName, Alias tableAlias) {
-        // 只有登陆用户的情况下，才进行数据权限的处理
-        LoginUser loginUser = SecurityFrameworkUtils.getLoginUser();
-        if (loginUser == null) {
-            return null;
-        }
-        // 只有MEMBER_ADMIN类型的用户，才进行数据权限的处理
-        if (ObjectUtil.notEqual(loginUser.getUserType(), UserTypeEnum.MEMBER_ADMIN.getValue())) {
-            return null;
-        }
-
-        if (!checkEnterprise(loginUser)) {
-            // 没有企业id
-            return null;
-        }
-        // 获得数据权限
-        DataPermissionRespDTO dataPermission = loginUser.getContext(CONTEXT_KEY, DataPermissionRespDTO.class);
-        // 从上下文中拿不到，则调用逻辑进行获取
-        if (dataPermission == null) {
-            Long enterpriseId = LoginUserContext.getEnterpriseId(loginUser);
-//            dataPermission = permissionApi.getDataPermission(loginUser.getId(), enterpriseId).getCheckedData();
-//            if (dataPermission == null) {
-//                log.error("[getExpression][LoginUser({}) 获取数据权限为 null]", JsonUtils.toJsonString(loginUser));
-//                throw new NullPointerException(String.format("LoginUser(%d) Table(%s/%s) 未返回数据权限",
-//                        loginUser.getId(), tableName, tableAlias.getName()));
-//            }
-            // 添加到上下文中，避免重复计算
-            loginUser.setContext(CONTEXT_KEY, dataPermission);
-        }
-
-        // 情况一，如果是 ALL 可查看全部，则无需拼接条件
-        if (dataPermission.getAll()) {
-            return null;
-        }
-
-        // 情况二，即不能查看部门，又不能查看自己，则说明 100% 无权限
-        if (CollUtil.isEmpty(dataPermission.getDataIds())
-                && Boolean.FALSE.equals(dataPermission.getSelf())) {
-            return new EqualsTo(null, null); // WHERE null = null，可以保证返回的数据为空
-        }
-
-        // 情况三，拼接 Dept 和 User 的条件，最后组合
-        Expression dataExpression = buildDeptExpression(tableName, tableAlias, dataPermission.getDataIds());
-        Expression userExpression = buildUserExpression(tableName, tableAlias, dataPermission.getSelf(), loginUser.getId());
-        if (dataExpression == null && userExpression == null) {
-            // TODO 芋艿：获得不到条件的时候，暂时不抛出异常，而是不返回数据
-            log.warn("[getExpression][LoginUser({}) Table({}/{}) DeptDataPermission({}) 构建的条件为空]",
-                    JsonUtils.toJsonString(loginUser), tableName, tableAlias, JsonUtils.toJsonString(dataPermission));
-            return EXPRESSION_NULL; // AND NULL
-        }
-
-        if (dataExpression == null) {
-            return userExpression;
-        }
-        if (userExpression == null) {
-            return dataExpression;
-        }
-        // // 目前，如果有指定数据 + 可查看自己，采用 OR 条件。即，WHERE (xx_id IN ? OR user_id = ?)
-        // return new Parenthesis(new OrExpression(dataExpression, userExpression));
-        // 改为 AND 条件。即，WHERE (xx_id IN ? and user_id = ?)
-        return new Parenthesis(new AndExpression(dataExpression, userExpression));
-    }
-
-    private Expression buildDeptExpression(String tableName, Alias tableAlias, Set<Long> dataIds) {
-        // 如果不存在配置，则无需作为条件
-        String columnName = DATA_COLUMNS.get(tableName);
-        if (StrUtil.isEmpty(columnName)) {
-            return null;
-        }
-        // 如果为空，则无条件
-        if (CollUtil.isEmpty(dataIds)) {
-            return null;
-        }
-        // 拼接条件
-        return new InExpression(MyBatisUtils.buildColumn(tableName, tableAlias, columnName),
-                new ExpressionList(CollectionUtils.convertList(dataIds, LongValue::new)));
-    }
-
-    private Expression buildUserExpression(String tableName, Alias tableAlias, Boolean self, Long userId) {
-        // 如果不查看自己，则无需作为条件
-        if (Boolean.FALSE.equals(self)) {
-            return null;
-        }
-        String columnName = USER_COLUMNS.get(tableName);
-        if (StrUtil.isEmpty(columnName)) {
-            return null;
-        }
-        // 拼接条件
-        return new EqualsTo(MyBatisUtils.buildColumn(tableName, tableAlias, columnName), new LongValue(userId));
-    }
-
-    // ==================== 添加配置 ====================
-    public void addDataColumn(Class<? extends BaseDO> entityClass, String columnName) {
-        String tableName = TableInfoHelper.getTableInfo(entityClass).getTableName();
-        addDataColumn(tableName, columnName);
-    }
-
-
-    public void addDataColumn(String tableName, String columnName) {
-        if (CharSequenceUtil.isEmpty(tableName)) {
-            return;
-        }
-        DATA_COLUMNS.put(tableName, columnName);
-        TABLE_NAMES.add(tableName);
-    }
-
-    public void addUserColumn(Class<? extends BaseDO> entityClass, String columnName) {
-        String tableName = TableInfoHelper.getTableInfo(entityClass).getTableName();
-        addUserColumn(tableName, columnName);
-    }
-
-    public void addUserColumn(String tableName, String columnName) {
-        if (CharSequenceUtil.isEmpty(tableName)) {
-            return;
-        }
-        USER_COLUMNS.put(tableName, columnName);
-        TABLE_NAMES.add(tableName);
-    }
-}

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/config/permission/CustomDataPermissionRuleCustomizer.java

@@ -1,18 +0,0 @@
-package com.citu.module.menduner.im.config.permission;
-
-/**
- * @author Rayson
- * @description CustomDataPermissionRuleCustomizer {@link CustomDataPermissionRule} 的自定义配置接口
- **/
-@FunctionalInterface
-public interface CustomDataPermissionRuleCustomizer {
-
-    /**
-     * 自定义该权限规则
-     * 1. 调用 {@link CustomDataPermissionRule#addDataColumn(Class, String)} 方法，配置基于数据编号的过滤规则
-     * 2. 调用 {@link CustomDataPermissionRule#addUserColumn(Class, String)} 方法，配置基于用户编号的过滤规则
-     *
-     * @param rule 权限规则
-     */
-    void customize(CustomDataPermissionRule rule);
-}

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/config/permission/package-info.java

@@ -1,6 +0,0 @@
-/**
- * 基于企业的数据权限规则
- *
- * @author Rayson
- */
-package com.citu.module.menduner.system.config.permission;

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/framework/datapermission/config/DataPermissionConfiguration.java

@@ -1,25 +0,0 @@
-package com.citu.module.menduner.im.framework.datapermission.config;
-
-
-import com.citu.framework.common.enums.UserTypeEnum;
-import com.citu.module.menduner.im.config.permission.CustomDataPermissionRuleCustomizer;
-
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-
-/**
- * menduner 模块的数据权限 Configuration
- *
- * @author Rayson
- */
-@Configuration(proxyBeanMethods = false)
-public class DataPermissionConfiguration {
-
-
-    @Bean
-    public CustomDataPermissionRuleCustomizer customDataPermissionRuleCustomizer() {
-        return rule -> {
-
-        };
-    }
-}

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/framework/security/config/SecurityConfiguration.java

@@ -10,10 +10,10 @@ import org.springframework.security.config.annotation.web.configurers.Expression
 /**
  * menduner 模块的 Security 配置
  */
-@Configuration("mendunerSecurityConfiguration")
+@Configuration("mendunerMiSecurityConfiguration")
 public class SecurityConfiguration {
 
-    @Bean("mendunerAuthorizeRequestsCustomizer")
+    @Bean("mendunerMiAuthorizeRequestsCustomizer")
     public AuthorizeRequestsCustomizer authorizeRequestsCustomizer() {
         return new AuthorizeRequestsCustomizer() {
 

menduner/menduner-im-biz/src/main/java/com/citu/module/menduner/im/package-info.java

@@ -1,4 +1,4 @@
 /**
  * menduner 招聘模块
  */
-package com.citu.module.menduner.system;
+package com.citu.module.menduner.im;

menduner/menduner-im-biz/src/main/resources/major/major.csv

@@ -1,817 +0,0 @@
-id,categorize,code,name_cn
-1,哲学类,010101,哲学
-2,哲学类,010102,逻辑学
-3,哲学类,010103K,宗教学
-4,哲学类,010104T,伦理学
-5,经济学类,020101,经济学
-6,经济学类,020102,经济统计学
-7,经济学类,020103T,国民经济管理
-8,经济学类,020104T,资源与环境经济学
-9,经济学类,020105T,商务经济学
-10,经济学类,020106T,能源经济
-11,经济学类,020107T,劳动经济学
-12,经济学类,020108T,经济工程
-13,经济学类,020109T,数字经济
-14,财政学类,020201K,财政学
-15,财政学类,020202,税收学
-16,财政学类,020203TK,国际税收
-17,金融学类,020301K,金融学
-18,金融学类,020302,金融工程
-19,金融学类,020303,保险学
-20,金融学类,020304,投资学
-21,金融学类,020305T,金融数学
-22,金融学类,020306T,信用管理
-23,金融学类,020307T,经济与金融
-24,金融学类,020308T,精算学
-25,金融学类,020309T,互联网金融
-26,金融学类,020310T,金融科技
-27,金融学类,020311TK,金融审计
-28,经济与贸易类,020401,国际经济与贸易
-29,经济与贸易类,020402,贸易经济
-30,经济与贸易类,020403T,国际经济发展合作
-31,法学类,030101K,法学
-32,法学类,030102T,知识产权
-33,法学类,030103T,监狱学
-34,法学类,030104T,信用风险管理与法律防控
-35,法学类,030105T,国际经贸规则
-36,法学类,030106TK,司法警察学
-37,法学类,030107TK,社区矫正
-38,法学类,030108TK,纪检监察
-39,法学类,030109TK,国际法
-40,法学类,030110TK,司法鉴定学
-41,法学类,030111TK,国家安全学
-42,法学类,030112TK,海外利益安全
-43,政治学类,030201,政治学与行政学
-44,政治学类,030202,国际政治
-45,政治学类,030203,外交学
-46,政治学类,030204T,国际事务与国际关系
-47,政治学类,030205T,政治学、经济学与哲学
-48,政治学类,030206TK,国际组织与全球治理
-49,社会学类,030301,社会学
-50,社会学类,030302,社会工作
-51,社会学类,030303T,人类学
-52,社会学类,030304T,女性学
-53,社会学类,030305T,家政学
-54,社会学类,030306T,老年学
-55,社会学类,030307T,社会政策
-56,民族学类,030401,民族学
-57,马克思主义理论类,030501,科学社会主义
-58,马克思主义理论类,030502,中国共产党历史
-59,马克思主义理论类,030503,思想政治教育
-60,马克思主义理论类,030504T,马克思主义理论
-61,马克思主义理论类,030505TK,工会学
-62,公安学类,030601K,治安学
-63,公安学类,030602K,侦查学
-64,公安学类,030603K,边防管理
-65,公安学类,030604TK,禁毒学
-66,公安学类,030605TK,警犬技术
-67,公安学类,030606TK,经济犯罪侦查
-68,公安学类,030607TK,边防指挥
-69,公安学类,030608TK,消防指挥
-70,公安学类,030609TK,警卫学
-71,公安学类,030610TK,公安情报学
-72,公安学类,030611TK,犯罪学
-73,公安学类,030612TK,公安管理学
-74,公安学类,030613TK,涉外警务
-75,公安学类,030614TK,国内安全保卫
-76,公安学类,030615TK,警务指挥与战术
-77,公安学类,030616TK,技术侦查学
-78,公安学类,030617TK,海警执法
-79,公安学类,030618TK,公安政治工作
-80,公安学类,030619TK,移民管理
-81,公安学类,030620TK,出入境管理
-82,公安学类,030621TK,反恐警务
-83,公安学类,030622TK,消防政治工作
-84,公安学类,030623TK,铁路警务
-85,教育学类,040101,教育学
-86,教育学类,040102,科学教育
-87,教育学类,040103,人文教育
-88,教育学类,040104,教育技术学
-89,教育学类,040105,艺术教育
-90,教育学类,040106,学前教育
-91,教育学类,040107,小学教育
-92,教育学类,040108,特殊教育
-93,教育学类,040109T,华文教育
-94,教育学类,040110TK,教育康复学
-95,教育学类,040111T,卫生教育
-96,教育学类,040112T,认知科学与技术
-97,教育学类,040113T,融合教育
-98,教育学类,040114TK,劳动教育
-99,教育学类,040115T,家庭教育
-100,教育学类,040116TK,孤独症儿童教育
-101,体育学类,040201,体育教育
-102,体育学类,040202K,运动训练
-103,体育学类,040203,社会体育指导与管理
-104,体育学类,040204K,武术与民族传统体育
-105,体育学类,040205,运动人体科学
-106,体育学类,040206T,运动康复
-107,体育学类,040207T,休闲体育
-108,体育学类,040208T,体能训练
-109,体育学类,040209T,冰雪运动
-110,体育学类,040210TK,电子竞技运动与管理
-111,体育学类,040211TK,智能体育工程
-112,体育学类,040212TK,体育旅游
-113,体育学类,040213T,运动能力开发
-114,体育学类,040214TK,足球运动
-115,体育学类,040215TK,马术运动与管理
-116,体育学类,040216T,体育康养
-117,中国语言文学类,050101,汉语言文学
-118,中国语言文学类,050102,汉语言
-119,中国语言文学类,050103,汉语国际教育
-120,中国语言文学类,050104,中国少数民族语言文学
-121,中国语言文学类,050105,古典文献学
-122,中国语言文学类,050106T,应用语言学
-123,中国语言文学类,050107T,秘书学
-124,中国语言文学类,050108T,中国语言与文化
-125,中国语言文学类,050109T,手语翻译
-126,中国语言文学类,050110T,数字人文
-127,中国语言文学类,050111T,中国古典学
-128,中国语言文学类,050112T,汉学与中国学
-129,中国语言文学类,050113T,应用中文
-130,外国语言文学类,050201,英语
-131,外国语言文学类,050202,俄语
-132,外国语言文学类,050203,德语
-133,外国语言文学类,050204,法语
-134,外国语言文学类,050205,西班牙语
-135,外国语言文学类,050206,阿拉伯语
-136,外国语言文学类,050207,日语
-137,外国语言文学类,050208,波斯语
-138,外国语言文学类,050209,朝鲜语
-139,外国语言文学类,050210,菲律宾语
-140,外国语言文学类,050211,梵语巴利语
-141,外国语言文学类,050212,印度尼西亚语
-142,外国语言文学类,050213,印地语
-143,外国语言文学类,050214,柬埔寨语
-144,外国语言文学类,050215,老挝语
-145,外国语言文学类,050216,缅甸语
-146,外国语言文学类,050217,马来语
-147,外国语言文学类,050218,蒙古语
-148,外国语言文学类,050219,僧伽罗语
-149,外国语言文学类,050220,泰语
-150,外国语言文学类,050221,乌尔都语
-151,外国语言文学类,050222,希伯来语
-152,外国语言文学类,050223,越南语
-153,外国语言文学类,050224,豪萨语
-154,外国语言文学类,050225,斯瓦希里语
-155,外国语言文学类,050226,阿尔巴尼亚语
-156,外国语言文学类,050227,保加利亚语
-157,外国语言文学类,050228,波兰语
-158,外国语言文学类,050229,捷克语
-159,外国语言文学类,050230,斯洛伐克语
-160,外国语言文学类,050231,罗马尼亚语
-161,外国语言文学类,050232,葡萄牙语
-162,外国语言文学类,050233,瑞典语
-163,外国语言文学类,050234,塞尔维亚语
-164,外国语言文学类,050235,土耳其语
-165,外国语言文学类,050236,希腊语
-166,外国语言文学类,050237,匈牙利语
-167,外国语言文学类,050238,意大利语
-168,外国语言文学类,050239,泰米尔语
-169,外国语言文学类,050240,普什图语
-170,外国语言文学类,050241,世界语
-171,外国语言文学类,050242,孟加拉语
-172,外国语言文学类,050243,尼泊尔语
-173,外国语言文学类,050244,克罗地亚语
-174,外国语言文学类,050245,荷兰语
-175,外国语言文学类,050246,芬兰语
-176,外国语言文学类,050247,乌克兰语
-177,外国语言文学类,050248,挪威语
-178,外国语言文学类,050249,丹麦语
-179,外国语言文学类,050250,冰岛语
-180,外国语言文学类,050251,爱尔兰语
-181,外国语言文学类,050252,拉脱维亚语
-182,外国语言文学类,050253,立陶宛语
-183,外国语言文学类,050254,斯洛文尼亚语
-184,外国语言文学类,050255,爱沙尼亚语
-185,外国语言文学类,050256,马耳他语
-186,外国语言文学类,050257,哈萨克语
-187,外国语言文学类,050258,乌兹别克语
-188,外国语言文学类,050259,祖鲁语
-189,外国语言文学类,050260,拉丁语
-190,外国语言文学类,050261,翻译
-191,外国语言文学类,050262,商务英语
-192,外国语言文学类,050263T,阿姆哈拉语
-193,外国语言文学类,050264T,吉尔吉斯语
-194,外国语言文学类,050265T,索马里语
-195,外国语言文学类,050266T,土库曼语
-196,外国语言文学类,050267T,加泰罗尼亚语
-197,外国语言文学类,050268T,约鲁巴语
-198,外国语言文学类,050269T,亚美尼亚语
-199,外国语言文学类,050270T,马达加斯加语
-200,外国语言文学类,050271T,格鲁吉亚语
-201,外国语言文学类,050272T,阿塞拜疆语
-202,外国语言文学类,050273T,阿非利卡语
-203,外国语言文学类,050274T,马其顿语
-204,外国语言文学类,050275T,塔吉克语
-205,外国语言文学类,050276T,茨瓦纳语
-206,外国语言文学类,050277T,恩德贝莱语
-207,外国语言文学类,050278T,科摩罗语
-208,外国语言文学类,050279T,克里奥尔语
-209,外国语言文学类,050280T,绍纳语
-210,外国语言文学类,050281T,提格雷尼亚语
-211,外国语言文学类,050282T,白俄罗斯语
-212,外国语言文学类,050283T,毛利语
-213,外国语言文学类,050284T,汤加语
-214,外国语言文学类,050285T,萨摩亚语
-215,外国语言文学类,050286T,库尔德语
-216,外国语言文学类,050287T,比斯拉马语
-217,外国语言文学类,050288T,达里语
-218,外国语言文学类,050289T,德顿语
-219,外国语言文学类,050290T,迪维希语
-220,外国语言文学类,050291T,斐济语
-221,外国语言文学类,050292T,库克群岛毛利语
-222,外国语言文学类,050293T,隆迪语
-223,外国语言文学类,050294T,卢森堡语
-224,外国语言文学类,050295T,卢旺达语
-225,外国语言文学类,050296T,纽埃语
-226,外国语言文学类,050297T,皮金语
-227,外国语言文学类,050298T,切瓦语
-228,外国语言文学类,050299T,塞苏陀语
-229,外国语言文学类,050200T,桑戈语
-230,外国语言文学类,0502100T,语言学
-231,外国语言文学类,0502101T,塔玛齐格特语
-232,外国语言文学类,0502102T,爪哇语
-233,外国语言文学类,0502103T,旁遮普语
-234,新闻传播学类,050301,新闻学
-235,新闻传播学类,050302,广播电视学
-236,新闻传播学类,050303,广告学
-237,新闻传播学类,050304,传播学
-238,新闻传播学类,050305,编辑出版学
-239,新闻传播学类,050306T,网络与新媒体
-240,新闻传播学类,050307T,数字出版
-241,新闻传播学类,050308T,时尚传播
-242,新闻传播学类,050309T,国际新闻与传播
-243,新闻传播学类,050310T,会展
-244,历史学类,060101,历史学
-245,历史学类,060102,世界史
-246,历史学类,060103,考古学
-247,历史学类,060104,文物与博物馆学
-248,历史学类,060105T,文物保护技术
-249,历史学类,060106T,外国语言与外国历史
-250,历史学类,060107T,文化遗产
-251,历史学类,060108T,古文字学
-252,历史学类,060109T,科学史
-253,数学类,070101,数学与应用数学
-254,数学类,070102,信息与计算科学
-255,数学类,070103T,数理基础科学
-256,数学类,070104T,数据计算及应用
-257,物理学类,070201,物理学
-258,物理学类,070202,应用物理学
-259,物理学类,070203,核物理
-260,物理学类,070204T,声学
-261,物理学类,070205T,系统科学与工程
-262,物理学类,070206T,量子信息科学
-263,化学类,070301,化学
-264,化学类,070302,应用化学
-265,化学类,070303T,化学生物学
-266,化学类,070304T,分子科学与工程
-267,化学类,070305T,能源化学
-268,化学类,070306T,化学测量学与技术
-269,化学类,070307T,资源化学
-270,天文学类,070401,天文学
-271,地理科学类,070501,地理科学
-272,地理科学类,070502,自然地理与资源环境
-273,地理科学类,070503,人文地理与城乡规划
-274,地理科学类,070504,地理信息科学
-275,大气科学类,070601,大气科学
-276,大气科学类,070602,应用气象学
-277,大气科学类,070603T,气象技术与工程
-278,大气科学类,070604T,地球系统科学
-279,海洋科学类,070701,海洋科学
-280,海洋科学类,070702,海洋技术
-281,海洋科学类,070703T,海洋资源与环境
-282,海洋科学类,070704T,军事海洋学
-283,地球物理学类,070801,地球物理学
-284,地球物理学类,070802,空间科学与技术
-285,地球物理学类,070803T,防灾减灾科学与工程
-286,地球物理学类,070804TK,行星科学
-287,地质学类,070901,地质学
-288,地质学类,070902,地球化学
-289,地质学类,070903T,地球信息科学与技术
-290,地质学类,070904T,古生物学
-291,生物科学类,071001,生物科学
-292,生物科学类,071002,生物技术
-293,生物科学类,071003,生物信息学
-294,生物科学类,071004,生态学
-295,生物科学类,071005T,整合科学
-296,生物科学类,071006T,神经科学
-297,心理学类,071101,心理学
-298,心理学类,071102,应用心理学
-299,统计学类,071201,统计学
-300,统计学类,071202,应用统计学
-301,统计学类,071203T,数据科学
-302,统计学类,071204T,生物统计学
-303,力学类,080101,理论与应用力学
-304,力学类,080102,工程力学
-305,机械类,080201,机械工程
-306,机械类,080202,机械设计制造及其自动化
-307,机械类,080203,材料成型及控制工程
-308,机械类,080204,机械电子工程
-309,机械类,080205,工业设计
-310,机械类,080206,过程装备与控制工程
-311,机械类,080207,车辆工程
-312,机械类,080208,汽车服务工程
-313,机械类,080209T,机械工艺技术
-314,机械类,080210T,微机电系统工程
-315,机械类,080211T,机电技术教育
-316,机械类,080212T,汽车维修工程教育
-317,机械类,080213T,智能制造工程
-318,机械类,080214T,智能车辆工程
-319,机械类,080215T,仿生科学与工程
-320,机械类,080216T,新能源汽车工程
-321,机械类,080217T,增材制造工程
-322,机械类,080218T,智能交互设计
-323,机械类,080219T,应急装备技术与工程
-324,机械类,080220T,农林智能装备工程
-325,仪器类,080301,测控技术与仪器
-326,仪器类,080302T,精密仪器
-327,仪器类,080303T,智能感知工程
-328,材料类,080401,材料科学与工程
-329,材料类,080402,材料物理
-330,材料类,080403,材料化学
-331,材料类,080404,冶金工程
-332,材料类,080405,金属材料工程
-333,材料类,080406,无机非金属材料工程
-334,材料类,080407,高分子材料与工程
-335,材料类,080408,复合材料与工程
-336,材料类,080409T,粉体材料科学与工程
-337,材料类,080410T,宝石及材料工艺学
-338,材料类,080411T,焊接技术与工程
-339,材料类,080412T,功能材料
-340,材料类,080413T,纳米材料与技术
-341,材料类,080414T,新能源材料与器件
-342,材料类,080415T,材料设计科学与工程
-343,材料类,080416T,复合材料成型工程
-344,材料类,080417T,智能材料与结构
-345,材料类,080418T,光电信息材料与器件
-346,材料类,080419T,生物材料
-347,材料类,080420T,材料智能技术
-348,材料类,080421T,电子信息材料
-349,材料类,080422T,软物质科学与工程
-350,材料类,080423T,稀土材料科学与工程
-351,能源动力类,080501,能源与动力工程
-352,能源动力类,080502T,能源与环境系统工程
-353,能源动力类,080503T,新能源科学与工程
-354,能源动力类,080504T,储能科学与工程
-355,能源动力类,080505T,能源服务工程
-356,能源动力类,080506TK,氢能科学与工程
-357,能源动力类,080507TK,可持续能源
-358,电气类,080601,电气工程及其自动化
-359,电气类,080602T,智能电网信息工程
-360,电气类,080603T,光源与照明
-361,电气类,080604T,电气工程与智能控制
-362,电气类,080605T,电机电器智能化
-363,电气类,080606T,电缆工程
-364,电气类,080607T,能源互联网工程
-365,电气类,080608TK,智慧能源工程
-366,电气类,080609T,电动载运工程
-367,电气类,080610TK,大功率半导体科学与工程
-368,电子信息类,080701,电子信息工程
-369,电子信息类,080702,电子科学与技术
-370,电子信息类,080703,通信工程
-371,电子信息类,080704,微电子科学与工程
-372,电子信息类,080705,光电信息科学与工程
-373,电子信息类,080706,信息工程
-374,电子信息类,080707T,广播电视工程
-375,电子信息类,080708T,水声工程
-376,电子信息类,080709T,电子封装技术
-377,电子信息类,080710T,集成电路设计与集成系统
-378,电子信息类,080711T,医学信息工程
-379,电子信息类,080712T,电磁场与无线技术
-380,电子信息类,080713T,电波传播与天线
-381,电子信息类,080714T,电子信息科学与技术
-382,电子信息类,080715T,电信工程及管理
-383,电子信息类,080716T,应用电子技术教育
-384,电子信息类,080717T,人工智能
-385,电子信息类,080718T,海洋信息工程
-386,电子信息类,080719T,柔性电子学
-387,电子信息类,080720T,智能测控工程
-388,电子信息类,080721T,智能视觉工程
-389,自动化类,080801,自动化
-390,自动化类,080802T,轨道交通信号与控制
-391,自动化类,080803T,机器人工程
-392,自动化类,080804T,邮政工程
-393,自动化类,080805T,核电技术与控制工程
-394,自动化类,080806T,智能装备与系统
-395,自动化类,080807T,工业智能
-396,自动化类,080808T,智能工程与创意设计
-397,计算机类,080901,计算机科学与技术
-398,计算机类,080902,软件工程
-399,计算机类,080903,网络工程
-400,计算机类,080904K,信息安全
-401,计算机类,080905,物联网工程
-402,计算机类,080906,数字媒体技术
-403,计算机类,080907T,智能科学与技术
-404,计算机类,080908T,空间信息与数字技术
-405,计算机类,080909T,电子与计算机工程
-406,计算机类,080910T,数据科学与大数据技术
-407,计算机类,080911TK,网络空间安全
-408,计算机类,080912T,新媒体技术
-409,计算机类,080913T,电影制作
-410,计算机类,080914TK,保密技术
-411,计算机类,080915T,服务科学与工程
-412,计算机类,080916T,虚拟现实技术
-413,计算机类,080917T,区块链工程
-414,计算机类,080918TK,密码科学与技术
-415,土木类,081001,土木工程
-416,土木类,081002,建筑环境与能源应用工程
-417,土木类,081003,给排水科学与工程
-418,土木类,081004,建筑电气与智能化
-419,土木类,081005T,城市地下空间工程
-420,土木类,081006T,道路桥梁与渡河工程
-421,土木类,081007T,铁道工程
-422,土木类,081008T,智能建造
-423,土木类,081009T,土木、水利与海洋工程
-424,土木类,081010T,土木、水利与交通工程
-425,土木类,081011T,城市水系统工程
-426,土木类,081012T,智能建造与智慧交通
-427,土木类,081013T,工程软件
-428,水利类,081101,水利水电工程
-429,水利类,081102,水文与水资源工程
-430,水利类,081103,港口航道与海岸工程
-431,水利类,081104T,水务工程
-432,水利类,081105T,水利科学与工程
-433,水利类,081106T,智慧水利
-434,测绘类,081201,测绘工程
-435,测绘类,081202,遥感科学与技术
-436,测绘类,081203T,导航工程
-437,测绘类,081204T,地理国情监测
-438,测绘类,081205T,地理空间信息工程
-439,化工与制药类,081301,化学工程与工艺
-440,化工与制药类,081302,制药工程
-441,化工与制药类,081303T,资源循环科学与工程
-442,化工与制药类,081304T,能源化学工程
-443,化工与制药类,081305T,化学工程与工业生物工程
-444,化工与制药类,081306T,化工安全工程
-445,化工与制药类,081307T,涂料工程
-446,化工与制药类,081308T,精细化工
-447,地质类,081401,地质工程
-448,地质类,081402,勘查技术与工程
-449,地质类,081403K,资源勘查工程
-450,地质类,081404T,地下水科学与工程
-451,地质类,081405T,旅游地学与规划工程
-452,地质类,081406T,智能地球探测
-453,地质类,081407T,资源环境大数据工程
-454,矿业类,081501,采矿工程
-455,矿业类,081502,石油工程
-456,矿业类,081503,矿物加工工程
-457,矿业类,081504,油气储运工程
-458,矿业类,081505T,矿物资源工程
-459,矿业类,081506T,海洋油气工程
-460,矿业类,081507T,智能采矿工程
-461,矿业类,081508TK,碳储科学与工程
-462,纺织类,081601,纺织工程
-463,纺织类,081602,服装设计与工程
-464,纺织类,081603T,非织造材料与工程
-465,纺织类,081604T,服装设计与工艺教育
-466,纺织类,081605T,丝绸设计与工程
-467,轻工类,081701,轻化工程
-468,轻工类,081702,包装工程
-469,轻工类,081703,印刷工程
-470,轻工类,081704T,香料香精技术与工程
-471,轻工类,081705T,化妆品技术与工程
-472,轻工类,081706TK,生物质能源与材料
-473,交通运输类,081801,交通运输
-474,交通运输类,081802,交通工程
-475,交通运输类,081803K,航海技术
-476,交通运输类,081804K,轮机工程
-477,交通运输类,081805K,飞行技术
-478,交通运输类,081806T,交通设备与控制工程
-479,交通运输类,081807T,救助与打捞工程
-480,交通运输类,081808TK,船舶电子电气工程
-481,交通运输类,081809T,轨道交通电气与控制
-482,交通运输类,081810T,邮轮工程与管理
-483,交通运输类,081811T,智慧交通
-484,交通运输类,081812T,智能运输工程
-485,海洋工程类,081901,船舶与海洋工程
-486,海洋工程类,081902T,海洋工程与技术
-487,海洋工程类,081903T,海洋资源开发技术
-488,海洋工程类,081904T,海洋机器人
-489,海洋工程类,081905T,智慧海洋技术
-490,海洋工程类,081906T,智能海洋装备
-491,航空航天类,082001,航空航天工程
-492,航空航天类,082002,飞行器设计与工程
-493,航空航天类,082003,飞行器制造工程
-494,航空航天类,082004,飞行器动力工程
-495,航空航天类,082005,飞行器环境与生命保障工程
-496,航空航天类,082006T,飞行器质量与可靠性
-497,航空航天类,082007T,飞行器适航技术
-498,航空航天类,082008T,飞行器控制与信息工程
-499,航空航天类,082009T,无人驾驶航空器系统工程
-500,航空航天类,082010T,智能飞行器技术
-501,航空航天类,082011T,空天智能电推进技术
-502,航空航天类,082012T,飞行器运维工程
-503,兵器类,082101,武器系统与工程
-504,兵器类,082102,武器发射工程
-505,兵器类,082103,探测制导与控制技术
-506,兵器类,082104,弹药工程与爆炸技术
-507,兵器类,082105,特种能源技术与工程
-508,兵器类,082106,装甲车辆工程
-509,兵器类,082107,信息对抗技术
-510,兵器类,082108T,智能无人系统技术
-511,核工程类,082201,核工程与核技术
-512,核工程类,082202,辐射防护与核安全
-513,核工程类,082203,工程物理
-514,核工程类,082204,核化工与核燃料工程
-515,农业工程类,082301,农业工程
-516,农业工程类,082302,农业机械化及其自动化
-517,农业工程类,082303,农业电气化
-518,农业工程类,082304,农业建筑环境与能源工程
-519,农业工程类,082305,农业水利工程
-520,农业工程类,082306T,土地整治工程
-521,农业工程类,082307T,农业智能装备工程
-522,林业工程类,082401,森林工程
-523,林业工程类,082402,木材科学与工程
-524,林业工程类,082403,林产化工
-525,林业工程类,082404T,家具设计与工程
-526,林业工程类,082405T,木结构建筑与材料
-527,环境科学与工程类,082501,环境科学与工程
-528,环境科学与工程类,082502,环境工程
-529,环境科学与工程类,082503,环境科学
-530,环境科学与工程类,082504,环境生态工程
-531,环境科学与工程类,082505T,环保设备工程
-532,环境科学与工程类,082506T,资源环境科学
-533,环境科学与工程类,082507T,水质科学与技术
-534,生物医学工程类,082601,生物医学工程
-535,生物医学工程类,082602T,假肢矫形工程
-536,生物医学工程类,082603T,临床工程技术
-537,生物医学工程类,082604T,康复工程
-538,生物医学工程类,082605T,健康科学与技术
-539,食品科学与工程类,082701,食品科学与工程
-540,食品科学与工程类,082702,食品质量与安全
-541,食品科学与工程类,082703,粮食工程
-542,食品科学与工程类,082704,乳品工程
-543,食品科学与工程类,082705,酿酒工程
-544,食品科学与工程类,082706T,葡萄与葡萄酒工程
-545,食品科学与工程类,082707T,食品营养与检验教育
-546,食品科学与工程类,082708T,烹饪与营养教育
-547,食品科学与工程类,082709T,食品安全与检测
-548,食品科学与工程类,082710T,食品营养与健康
-549,食品科学与工程类,082711T,食用菌科学与工程
-550,食品科学与工程类,082712T,白酒酿造工程
-551,食品科学与工程类,082713T,咖啡科学与工程
-552,建筑类,082801,建筑学
-553,建筑类,082802,城乡规划
-554,建筑类,082803,风景园林
-555,建筑类,082804T,历史建筑保护工程
-556,建筑类,082805T,人居环境科学与技术
-557,建筑类,082806T,城市设计
-558,建筑类,082807T,智慧建筑与建造
-559,安全科学与工程类,082901,安全工程
-560,安全科学与工程类,082902T,应急技术与管理
-561,安全科学与工程类,082903T,职业卫生工程
-562,安全科学与工程类,082904T,安全生产监管
-563,生物工程类,083001,生物工程
-564,生物工程类,083002T,生物制药
-565,生物工程类,083003T,合成生物学
-566,公安技术类,083101K,刑事科学技术
-567,公安技术类,083102K,消防工程
-568,公安技术类,083103TK,交通管理工程
-569,公安技术类,083104TK,安全防范工程
-570,公安技术类,083105TK,公安视听技术
-571,公安技术类,083106TK,抢险救援指挥与技术
-572,公安技术类,083107TK,火灾勘查
-573,公安技术类,083108TK,网络安全与执法
-574,公安技术类,083109TK,核生化消防
-575,公安技术类,083110TK,海警舰艇指挥与技术
-576,公安技术类,083111TK,数据警务技术
-577,公安技术类,083112TK,食品药品环境犯罪侦查技术
-578,交叉工程类,083201TK,未来机器人
-579,交叉工程类,083202TK,交叉工程
-580,植物生产类,090101,农学
-581,植物生产类,090102,园艺
-582,植物生产类,090103,植物保护
-583,植物生产类,090104,植物科学与技术
-584,植物生产类,090105,种子科学与工程
-585,植物生产类,090106,设施农业科学与工程
-586,植物生产类,090107T,茶学
-587,植物生产类,090108T,烟草
-588,植物生产类,090109T,应用生物科学
-589,植物生产类,090110T,农艺教育
-590,植物生产类,090111T,园艺教育
-591,植物生产类,090112T,智慧农业
-592,植物生产类,090113T,菌物科学与工程
-593,植物生产类,090114T,农药化肥
-594,植物生产类,090115T,生物农药科学与工程
-595,植物生产类,090116TK,生物育种科学
-596,植物生产类,090117TK,生物育种技术
-597,自然保护与环境生态类,090201,农业资源与环境
-598,自然保护与环境生态类,090202,野生动物与自然保护区管理
-599,自然保护与环境生态类,090203,水土保持与荒漠化防治
-600,自然保护与环境生态类,090204T,生物质科学与工程
-601,自然保护与环境生态类,090205T,土地科学与技术
-602,自然保护与环境生态类,090206T,湿地保护与恢复
-603,自然保护与环境生态类,090207TK,国家公园建设与管理
-604,自然保护与环境生态类,090208TK,生态修复学
-605,动物生产类,090301,动物科学
-606,动物生产类,090302T,蚕学
-607,动物生产类,090303T,蜂学
-608,动物生产类,090304T,经济动物学
-609,动物生产类,090305T,马业科学
-610,动物生产类,090306T,饲料工程
-611,动物生产类,090307T,智慧牧业科学与工程
-612,动物医学类,090401,动物医学
-613,动物医学类,090402,动物药学
-614,动物医学类,090403T,动植物检疫
-615,动物医学类,090404T,实验动物学
-616,动物医学类,090405T,中兽医学
-617,动物医学类,090406TK,兽医公共卫生
-618,林学类,090501,林学
-619,林学类,090502,园林
-620,林学类,090503,森林保护
-621,林学类,090504T,经济林
-622,林学类,090505T,智慧林业
-623,水产类,090601,水产养殖学
-624,水产类,090602,海洋渔业科学与技术
-625,水产类,090603T,水族科学与技术
-626,水产类,090604TK,水生动物医学
-627,草学类,090701,草业科学
-628,草学类,090702T,草坪科学与工程
-629,基础医学类,100101K,基础医学
-630,基础医学类,100102TK,生物医学
-631,基础医学类,100103T,生物医学科学
-632,临床医学类,100201K,临床医学
-633,临床医学类,100202TK,麻醉学
-634,临床医学类,100203TK,医学影像学
-635,临床医学类,100204TK,眼视光医学
-636,临床医学类,100205TK,精神医学
-637,临床医学类,100206TK,放射医学
-638,临床医学类,100207TK,儿科学
-639,口腔医学类,100301K,口腔医学
-640,公共卫生与预防医学类,100401K,预防医学
-641,公共卫生与预防医学类,100402,食品卫生与营养学
-642,公共卫生与预防医学类,100403TK,妇幼保健医学
-643,公共卫生与预防医学类,100404TK,卫生监督
-644,公共卫生与预防医学类,100405TK,全球健康学
-645,公共卫生与预防医学类,100406T,运动与公共健康
-646,中医学类,100501K,中医学
-647,中医学类,100502K,针灸推拿学
-648,中医学类,100503K,藏医学
-649,中医学类,100504K,蒙医学
-650,中医学类,100505K,维医学
-651,中医学类,100506K,壮医学
-652,中医学类,100507K,哈医学
-653,中医学类,100508TK,傣医学
-654,中医学类,100509TK,回医学
-655,中医学类,100510TK,中医康复学
-656,中医学类,100511TK,中医养生学
-657,中医学类,100512TK,中医儿科学
-658,中医学类,100513TK,中医骨伤科学
-659,中西医结合类,100601K,中西医临床医学
-660,药学类,100701,药学
-661,药学类,100702,药物制剂
-662,药学类,100703TK,临床药学
-663,药学类,100704T,药事管理
-664,药学类,100705T,药物分析
-665,药学类,100706T,药物化学
-666,药学类,100707T,海洋药学
-667,药学类,100708T,化妆品科学与技术
-668,中药学类,100801,中药学
-669,中药学类,100802,中药资源与开发
-670,中药学类,100803T,藏药学
-671,中药学类,100804T,蒙药学
-672,中药学类,100805T,中药制药
-673,中药学类,100806T,中草药栽培与鉴定
-674,法医学类,100901K,法医学
-675,医学技术类,101001,医学检验技术
-676,医学技术类,101002,医学实验技术
-677,医学技术类,101003,医学影像技术
-678,医学技术类,101004,眼视光学
-679,医学技术类,101005,康复治疗学
-680,医学技术类,101006,口腔医学技术
-681,医学技术类,101007,卫生检验与检疫
-682,医学技术类,101008T,听力与言语康复学
-683,医学技术类,101009T,康复物理治疗
-684,医学技术类,101010T,康复作业治疗
-685,医学技术类,101011T,智能医学工程
-686,医学技术类,101012T,生物医药数据科学
-687,医学技术类,101013T,智能影像工程
-688,医学技术类,101014TK,医工学
-689,护理学类,101101K,护理学
-690,护理学类,101102TK,助产学
-691,管理科学与工程类,120101,管理科学
-692,管理科学与工程类,120102,信息管理与信息系统
-693,管理科学与工程类,120103,工程管理
-694,管理科学与工程类,120104,房地产开发与管理
-695,管理科学与工程类,120105,工程造价
-696,管理科学与工程类,120106TK,保密管理
-697,管理科学与工程类,120107T,邮政管理
-698,管理科学与工程类,120108T,大数据管理与应用
-699,管理科学与工程类,120109T,工程审计
-700,管理科学与工程类,120110T,计算金融
-701,管理科学与工程类,120111T,应急管理
-702,工商管理类,120201K,工商管理
-703,工商管理类,120202,市场营销
-704,工商管理类,120203K,会计学
-705,工商管理类,120204,财务管理
-706,工商管理类,120205,国际商务
-707,工商管理类,120206,人力资源管理
-708,工商管理类,120207,审计学
-709,工商管理类,120208,资产评估
-710,工商管理类,120209,物业管理
-711,工商管理类,120210,文化产业管理
-712,工商管理类,120211T,劳动关系
-713,工商管理类,120212T,体育经济与管理
-714,工商管理类,120213T,财务会计教育
-715,工商管理类,120214T,市场营销教育
-716,工商管理类,120215T,零售业管理
-717,工商管理类,120216T,创业管理
-718,工商管理类,120217TK,海关稽查
-719,工商管理类,120218T,内部审计
-720,农业经济管理类,120301,农林经济管理
-721,农业经济管理类,120302,农村区域发展
-722,农业经济管理类,120303TK,乡村治理
-723,公共管理类,120401,公共事业管理
-724,公共管理类,120402,行政管理
-725,公共管理类,120403,劳动与社会保障
-726,公共管理类,120404,土地资源管理
-727,公共管理类,120405,城市管理
-728,公共管理类,120406TK,海关管理
-729,公共管理类,120407T,交通管理
-730,公共管理类,120408T,海事管理
-731,公共管理类,120409T,公共关系学
-732,公共管理类,120410T,健康服务与管理
-733,公共管理类,120411TK,海警后勤管理
-734,公共管理类,120412T,医疗产品管理
-735,公共管理类,120413T,医疗保险
-736,公共管理类,120414T,养老服务管理
-737,公共管理类,120415TK,海关检验检疫安全
-738,公共管理类,120416TK,海外安全管理
-739,公共管理类,120417T,自然资源登记与管理
-740,公共管理类,120418T,慈善管理
-741,公共管理类,120419TK,航空安防管理
-742,公共管理类,120420TK,无障碍管理
-743,图书情报与档案管理类,120501,图书馆学
-744,图书情报与档案管理类,120502,档案学
-745,图书情报与档案管理类,120503,信息资源管理
-746,物流管理与工程类,120601,物流管理
-747,物流管理与工程类,120602,物流工程
-748,物流管理与工程类,120603T,采购管理
-749,物流管理与工程类,120604T,供应链管理
-750,工业工程类,120701,工业工程
-751,工业工程类,120702T,标准化工程
-752,工业工程类,120703T,质量管理工程
-753,电子商务类,120801,电子商务
-754,电子商务类,120802T,电子商务及法律
-755,电子商务类,120803T,跨境电子商务
-756,旅游管理类,120901K,旅游管理
-757,旅游管理类,120902,酒店管理
-758,旅游管理类,120903,会展经济与管理
-759,旅游管理类,120904T,旅游管理与服务教育
-760,艺术学理论类,130101,艺术史论
-761,艺术学理论类,130102T,艺术管理
-762,艺术学理论类,130103T,非物质文化遗产保护
-763,音乐与舞蹈学类,130201,音乐表演
-764,音乐与舞蹈学类,130202,音乐学
-765,音乐与舞蹈学类,130203,作曲与作曲技术理论
-766,音乐与舞蹈学类,130204,舞蹈表演
-767,音乐与舞蹈学类,130205,舞蹈学
-768,音乐与舞蹈学类,130206,舞蹈编导
-769,音乐与舞蹈学类,130207T,舞蹈教育
-770,音乐与舞蹈学类,130208TK,航空服务艺术与管理
-771,音乐与舞蹈学类,130209T,流行音乐
-772,音乐与舞蹈学类,130210T,音乐治疗
-773,音乐与舞蹈学类,130211T,流行舞蹈
-774,音乐与舞蹈学类,130212T,音乐教育
-775,音乐与舞蹈学类,130213TK,冰雪舞蹈表演
-776,戏剧与影视学类,130301,表演
-777,戏剧与影视学类,130302,戏剧学
-778,戏剧与影视学类,130303,电影学
-779,戏剧与影视学类,130304,戏剧影视文学
-780,戏剧与影视学类,130305,广播电视编导
-781,戏剧与影视学类,130306,戏剧影视导演
-782,戏剧与影视学类,130307,戏剧影视美术设计
-783,戏剧与影视学类,130308,录音艺术
-784,戏剧与影视学类,130309,播音与主持艺术
-785,戏剧与影视学类,130310,动画
-786,戏剧与影视学类,130311T,影视摄影与制作
-787,戏剧与影视学类,130312T,影视技术
-788,戏剧与影视学类,130313T,戏剧教育
-789,戏剧与影视学类,130314TK,曲艺
-790,戏剧与影视学类,130315TK,音乐剧
-791,美术学类,130401,美术学
-792,美术学类,130402,绘画
-793,美术学类,130403,雕塑
-794,美术学类,130404,摄影
-795,美术学类,130405T,书法学
-796,美术学类,130406T,中国画
-797,美术学类,130407TK,实验艺术
-798,美术学类,130408TK,跨媒体艺术
-799,美术学类,130409T,文物保护与修复
-800,美术学类,130410T,漫画
-801,美术学类,130411T,纤维艺术
-802,美术学类,130412TK,科技艺术
-803,美术学类,130413TK,美术教育
-804,设计学类,130501,艺术设计学
-805,设计学类,130502,视觉传达设计
-806,设计学类,130503,环境设计
-807,设计学类,130504,产品设计
-808,设计学类,130505,服装与服饰设计
-809,设计学类,130506,公共艺术
-810,设计学类,130507,工艺美术
-811,设计学类,130508,数字媒体艺术
-812,设计学类,130509T,艺术与科技
-813,设计学类,130510TK,陶瓷艺术设计
-814,设计学类,130511T,新媒体艺术
-815,设计学类,130512T,包装设计
-816,设计学类,130513TK,珠宝首饰设计与工艺

menduner/menduner-im-biz/src/main/resources/major/readme.txt

@@ -1,5 +0,0 @@
-来源
-http://www.moe.gov.cn/srcsite/A08/moe_1034/s4930/202403/W020240319305498791768.pdf
-
-转换成Excel
-https://smallpdf.com/cn/pdf-to-excel#r=convert-to-excel

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/area/AreaServiceImplTest.java

@@ -1,136 +0,0 @@
-package com.citu.module.menduner.system.service.area;
-
-import com.citu.module.menduner.system.controller.base.area.AreaPageReqVO;
-import com.citu.module.menduner.system.controller.base.area.AreaSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.area.AreaDO;
-import com.citu.module.menduner.system.dal.mysql.area.AreaMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_AREA_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link AreaServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(AreaServiceImpl.class)
-public class AreaServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private AreaServiceImpl areaService;
-
-    @Resource
-    private AreaMapper areaMapper;
-
-    @Test
-    public void testCreateArea_success() {
-        // 准备参数
-        AreaSaveReqVO createReqVO = randomPojo(AreaSaveReqVO.class).setId(null);
-
-        // 调用
-        Long areaId = areaService.createArea(createReqVO);
-        // 断言
-        assertNotNull(areaId);
-        // 校验记录的属性是否正确
-        AreaDO area = areaMapper.selectById(areaId);
-        assertPojoEquals(createReqVO, area, "id");
-    }
-
-    @Test
-    public void testUpdateArea_success() {
-        // mock 数据
-        AreaDO dbArea = randomPojo(AreaDO.class);
-        areaMapper.insert(dbArea);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        AreaSaveReqVO updateReqVO = randomPojo(AreaSaveReqVO.class, o -> {
-            o.setId(dbArea.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        areaService.updateArea(updateReqVO);
-        // 校验是否更新正确
-        AreaDO area = areaMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, area);
-    }
-
-    @Test
-    public void testUpdateArea_notExists() {
-        // 准备参数
-        AreaSaveReqVO updateReqVO = randomPojo(AreaSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> areaService.updateArea(updateReqVO), MDE_AREA_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteArea_success() {
-        // mock 数据
-        AreaDO dbArea = randomPojo(AreaDO.class);
-        areaMapper.insert(dbArea);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbArea.getId();
-
-        // 调用
-        areaService.deleteArea(id);
-       // 校验数据不存在了
-       assertNull(areaMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteArea_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> areaService.deleteArea(id), MDE_AREA_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetAreaPage() {
-       // mock 数据
-       AreaDO dbArea = randomPojo(AreaDO.class, o -> { // 等会查询到
-           o.setName(null);
-           o.setType(null);
-           o.setParentId(null);
-           o.setCreateTime(null);
-       });
-       areaMapper.insert(dbArea);
-       // 测试 name 不匹配
-       areaMapper.insert(cloneIgnoreId(dbArea, o -> o.setName(null)));
-       // 测试 type 不匹配
-       areaMapper.insert(cloneIgnoreId(dbArea, o -> o.setType(null)));
-       // 测试 parentId 不匹配
-       areaMapper.insert(cloneIgnoreId(dbArea, o -> o.setParentId(null)));
-       // 测试 createTime 不匹配
-       areaMapper.insert(cloneIgnoreId(dbArea, o -> o.setCreateTime(null)));
-       // 准备参数
-       AreaPageReqVO reqVO = new AreaPageReqVO();
-       reqVO.setName(null);
-       reqVO.setType(null);
-       reqVO.setParentId(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<AreaDO> pageResult = areaService.getAreaPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbArea, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/certificate/CertificateServiceImplTest.java

@@ -1,140 +0,0 @@
-package com.citu.module.menduner.system.service.certificate;
-
-import com.citu.module.menduner.system.controller.base.certificate.CertificatePageReqVO;
-import com.citu.module.menduner.system.controller.base.certificate.CertificateSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.certificate.CertificateDO;
-import com.citu.module.menduner.system.dal.mysql.certificate.CertificateMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_CERTIFICATE_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link CertificateServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(CertificateServiceImpl.class)
-public class CertificateServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private CertificateServiceImpl certificateService;
-
-    @Resource
-    private CertificateMapper certificateMapper;
-
-    @Test
-    public void testCreateCertificate_success() {
-        // 准备参数
-        CertificateSaveReqVO createReqVO = randomPojo(CertificateSaveReqVO.class).setId(null);
-
-        // 调用
-        Long certificateId = certificateService.createCertificate(createReqVO);
-        // 断言
-        assertNotNull(certificateId);
-        // 校验记录的属性是否正确
-        CertificateDO certificate = certificateMapper.selectById(certificateId);
-        assertPojoEquals(createReqVO, certificate, "id");
-    }
-
-    @Test
-    public void testUpdateCertificate_success() {
-        // mock 数据
-        CertificateDO dbCertificate = randomPojo(CertificateDO.class);
-        certificateMapper.insert(dbCertificate);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        CertificateSaveReqVO updateReqVO = randomPojo(CertificateSaveReqVO.class, o -> {
-            o.setId(dbCertificate.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        certificateService.updateCertificate(updateReqVO);
-        // 校验是否更新正确
-        CertificateDO certificate = certificateMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, certificate);
-    }
-
-    @Test
-    public void testUpdateCertificate_notExists() {
-        // 准备参数
-        CertificateSaveReqVO updateReqVO = randomPojo(CertificateSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> certificateService.updateCertificate(updateReqVO), MDE_CERTIFICATE_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteCertificate_success() {
-        // mock 数据
-        CertificateDO dbCertificate = randomPojo(CertificateDO.class);
-        certificateMapper.insert(dbCertificate);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbCertificate.getId();
-
-        // 调用
-        certificateService.deleteCertificate(id);
-       // 校验数据不存在了
-       assertNull(certificateMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteCertificate_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> certificateService.deleteCertificate(id), MDE_CERTIFICATE_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetCertificatePage() {
-       // mock 数据
-       CertificateDO dbCertificate = randomPojo(CertificateDO.class, o -> { // 等会查询到
-           o.setNameCn(null);
-           o.setNameEn(null);
-           o.setParentId(null);
-           o.setLevel(null);
-           o.setCreateTime(null);
-       });
-       certificateMapper.insert(dbCertificate);
-       // 测试 nameCn 不匹配
-       certificateMapper.insert(cloneIgnoreId(dbCertificate, o -> o.setNameCn(null)));
-       // 测试 nameEn 不匹配
-       certificateMapper.insert(cloneIgnoreId(dbCertificate, o -> o.setNameEn(null)));
-       // 测试 parentId 不匹配
-       certificateMapper.insert(cloneIgnoreId(dbCertificate, o -> o.setParentId(null)));
-       // 测试 level 不匹配
-       certificateMapper.insert(cloneIgnoreId(dbCertificate, o -> o.setLevel(null)));
-       // 测试 createTime 不匹配
-       certificateMapper.insert(cloneIgnoreId(dbCertificate, o -> o.setCreateTime(null)));
-       // 准备参数
-       CertificatePageReqVO reqVO = new CertificatePageReqVO();
-       reqVO.setNameCn(null);
-       reqVO.setNameEn(null);
-       reqVO.setParentId(null);
-       reqVO.setLevel(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<CertificateDO> pageResult = certificateService.getCertificatePage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbCertificate, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/cvattachment/CvAttachmentServiceImplTest.java

@@ -1,136 +0,0 @@
-package com.citu.module.menduner.system.service.cvattachment;
-
-import com.citu.module.menduner.system.controller.base.cvattachment.CvAttachmentPageReqVO;
-import com.citu.module.menduner.system.controller.base.cvattachment.CvAttachmentSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.cvattachment.CvAttachmentDO;
-import com.citu.module.menduner.system.dal.mysql.cvattachment.CvAttachmentMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_CV_ATTACHMENT_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link CvAttachmentServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(CvAttachmentServiceImpl.class)
-public class CvAttachmentServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private CvAttachmentServiceImpl cvAttachmentService;
-
-    @Resource
-    private CvAttachmentMapper cvAttachmentMapper;
-
-    @Test
-    public void testCreateCvAttachment_success() {
-        // 准备参数
-        CvAttachmentSaveReqVO createReqVO = randomPojo(CvAttachmentSaveReqVO.class).setId(null);
-
-        // 调用
-        Long cvAttachmentId = cvAttachmentService.createCvAttachment(createReqVO);
-        // 断言
-        assertNotNull(cvAttachmentId);
-        // 校验记录的属性是否正确
-        CvAttachmentDO cvAttachment = cvAttachmentMapper.selectById(cvAttachmentId);
-        assertPojoEquals(createReqVO, cvAttachment, "id");
-    }
-
-    @Test
-    public void testUpdateCvAttachment_success() {
-        // mock 数据
-        CvAttachmentDO dbCvAttachment = randomPojo(CvAttachmentDO.class);
-        cvAttachmentMapper.insert(dbCvAttachment);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        CvAttachmentSaveReqVO updateReqVO = randomPojo(CvAttachmentSaveReqVO.class, o -> {
-            o.setId(dbCvAttachment.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        cvAttachmentService.updateCvAttachment(updateReqVO);
-        // 校验是否更新正确
-        CvAttachmentDO cvAttachment = cvAttachmentMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, cvAttachment);
-    }
-
-    @Test
-    public void testUpdateCvAttachment_notExists() {
-        // 准备参数
-        CvAttachmentSaveReqVO updateReqVO = randomPojo(CvAttachmentSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> cvAttachmentService.updateCvAttachment(updateReqVO), MDE_CV_ATTACHMENT_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteCvAttachment_success() {
-        // mock 数据
-        CvAttachmentDO dbCvAttachment = randomPojo(CvAttachmentDO.class);
-        cvAttachmentMapper.insert(dbCvAttachment);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbCvAttachment.getId();
-
-        // 调用
-        cvAttachmentService.deleteCvAttachment(id);
-       // 校验数据不存在了
-       assertNull(cvAttachmentMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteCvAttachment_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> cvAttachmentService.deleteCvAttachment(id), MDE_CV_ATTACHMENT_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetCvAttachmentPage() {
-       // mock 数据
-       CvAttachmentDO dbCvAttachment = randomPojo(CvAttachmentDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setTitle(null);
-           o.setUrl(null);
-           o.setCreateTime(null);
-       });
-       cvAttachmentMapper.insert(dbCvAttachment);
-       // 测试 userId 不匹配
-       cvAttachmentMapper.insert(cloneIgnoreId(dbCvAttachment, o -> o.setUserId(null)));
-       // 测试 title 不匹配
-       cvAttachmentMapper.insert(cloneIgnoreId(dbCvAttachment, o -> o.setTitle(null)));
-       // 测试 url 不匹配
-       cvAttachmentMapper.insert(cloneIgnoreId(dbCvAttachment, o -> o.setUrl(null)));
-       // 测试 createTime 不匹配
-       cvAttachmentMapper.insert(cloneIgnoreId(dbCvAttachment, o -> o.setCreateTime(null)));
-       // 准备参数
-       CvAttachmentPageReqVO reqVO = new CvAttachmentPageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setTitle(null);
-       reqVO.setUrl(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<CvAttachmentDO> pageResult = cvAttachmentService.getCvAttachmentPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbCvAttachment, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/eduexp/EduExpServiceImplTest.java

@@ -1,166 +0,0 @@
-package com.citu.module.menduner.system.service.eduexp;
-
-import com.citu.module.menduner.system.controller.base.eduexp.EduExpPageReqVO;
-import com.citu.module.menduner.system.controller.base.eduexp.EduExpSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.eduexp.EduExpDO;
-import com.citu.module.menduner.system.dal.mysql.eduexp.EduExpMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import java.time.LocalDateTime;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_EDU_EXP_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EduExpServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EduExpServiceImpl.class)
-public class EduExpServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EduExpServiceImpl eduExpService;
-
-    @Resource
-    private EduExpMapper eduExpMapper;
-
-    @Test
-    public void testCreateEduExp_success() {
-        // 准备参数
-        EduExpSaveReqVO createReqVO = randomPojo(EduExpSaveReqVO.class).setId(null);
-
-        // 调用
-        Long eduExpId = eduExpService.createEduExp(createReqVO);
-        // 断言
-        assertNotNull(eduExpId);
-        // 校验记录的属性是否正确
-        EduExpDO eduExp = eduExpMapper.selectById(eduExpId);
-        assertPojoEquals(createReqVO, eduExp, "id");
-    }
-
-    @Test
-    public void testUpdateEduExp_success() {
-        // mock 数据
-        EduExpDO dbEduExp = randomPojo(EduExpDO.class);
-        eduExpMapper.insert(dbEduExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EduExpSaveReqVO updateReqVO = randomPojo(EduExpSaveReqVO.class, o -> {
-            o.setId(dbEduExp.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        eduExpService.updateEduExp(updateReqVO);
-        // 校验是否更新正确
-        EduExpDO eduExp = eduExpMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, eduExp);
-    }
-
-    @Test
-    public void testUpdateEduExp_notExists() {
-        // 准备参数
-        EduExpSaveReqVO updateReqVO = randomPojo(EduExpSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> eduExpService.updateEduExp(updateReqVO), MDE_EDU_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEduExp_success() {
-        // mock 数据
-        EduExpDO dbEduExp = randomPojo(EduExpDO.class);
-        eduExpMapper.insert(dbEduExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEduExp.getId();
-
-        // 调用
-        eduExpService.deleteEduExp(id);
-       // 校验数据不存在了
-       assertNull(eduExpMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEduExp_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> eduExpService.deleteEduExp(id), MDE_EDU_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEduExpPage() {
-       // mock 数据
-       EduExpDO dbEduExp = randomPojo(EduExpDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setSchoolId(null);
-           o.setSchoolName(null);
-           o.setEducationType(null);
-           o.setEducationSystemType(null);
-           o.setMajorId(null);
-           o.setMajor(null);
-           o.setStartTime(null);
-           o.setEndTime(null);
-           o.setContent(null);
-           o.setCreateTime(null);
-       });
-       eduExpMapper.insert(dbEduExp);
-       // 测试 userId 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setUserId(null)));
-       // 测试 schoolId 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setSchoolId(null)));
-       // 测试 schoolName 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setSchoolName(null)));
-       // 测试 educationType 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setEducationType(null)));
-       // 测试 educationSystemType 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setEducationSystemType(null)));
-       // 测试 majorId 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setMajorId(null)));
-       // 测试 major 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setMajor(null)));
-       // 测试 startTime 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setStartTime(null)));
-       // 测试 endTime 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setEndTime(null)));
-       // 测试 content 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setContent(null)));
-       // 测试 createTime 不匹配
-       eduExpMapper.insert(cloneIgnoreId(dbEduExp, o -> o.setCreateTime(null)));
-       // 准备参数
-       EduExpPageReqVO reqVO = new EduExpPageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setSchoolId(null);
-       reqVO.setSchoolName(null);
-       reqVO.setEducationType(null);
-       reqVO.setEducationSystemType(null);
-       reqVO.setMajorId(null);
-       reqVO.setMajor(null);
-       reqVO.setStartTime(LocalDateTime.now());
-       reqVO.setEndTime(LocalDateTime.now());
-       reqVO.setContent(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<EduExpDO> pageResult = eduExpService.getEduExpPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbEduExp, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseAddressServiceImplTest.java

@@ -1,133 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.address.EnterpriseAddressPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.address.EnterpriseAddressSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseAddressDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseAddressMapper;
-import com.citu.module.menduner.system.service.enterprise.address.EnterpriseAddressServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_ENTERPRISE_ADDRESS_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseAddressServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseAddressServiceImpl.class)
-public class EnterpriseAddressServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseAddressServiceImpl enterpriseAddressService;
-
-    @Resource
-    private EnterpriseAddressMapper enterpriseAddressMapper;
-
-    @Test
-    public void testCreateEnterpriseAddress_success() {
-        // 准备参数
-        EnterpriseAddressSaveReqVO createReqVO = randomPojo(EnterpriseAddressSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseAddressId = enterpriseAddressService.createEnterpriseAddress(createReqVO);
-        // 断言
-        assertNotNull(enterpriseAddressId);
-        // 校验记录的属性是否正确
-        EnterpriseAddressDO enterpriseAddress = enterpriseAddressMapper.selectById(enterpriseAddressId);
-        assertPojoEquals(createReqVO, enterpriseAddress, "id");
-    }
-
-    @Test
-    public void testUpdateEnterpriseAddress_success() {
-        // mock 数据
-        EnterpriseAddressDO dbEnterpriseAddress = randomPojo(EnterpriseAddressDO.class);
-        enterpriseAddressMapper.insert(dbEnterpriseAddress);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseAddressSaveReqVO updateReqVO = randomPojo(EnterpriseAddressSaveReqVO.class, o -> {
-            o.setId(dbEnterpriseAddress.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseAddressService.updateEnterpriseAddress(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseAddressDO enterpriseAddress = enterpriseAddressMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterpriseAddress);
-    }
-
-    @Test
-    public void testUpdateEnterpriseAddress_notExists() {
-        // 准备参数
-        EnterpriseAddressSaveReqVO updateReqVO = randomPojo(EnterpriseAddressSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseAddressService.updateEnterpriseAddress(updateReqVO), MDE_ENTERPRISE_ADDRESS_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterpriseAddress_success() {
-        // mock 数据
-        EnterpriseAddressDO dbEnterpriseAddress = randomPojo(EnterpriseAddressDO.class);
-        enterpriseAddressMapper.insert(dbEnterpriseAddress);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterpriseAddress.getId();
-
-        // 调用
-        enterpriseAddressService.deleteEnterpriseAddress(id);
-        // 校验数据不存在了
-        assertNull(enterpriseAddressMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterpriseAddress_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseAddressService.deleteEnterpriseAddress(id), MDE_ENTERPRISE_ADDRESS_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterpriseAddressPage() {
-        // mock 数据
-        EnterpriseAddressDO dbEnterpriseAddress = randomPojo(EnterpriseAddressDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setAddress(null);
-            o.setCreateTime(null);
-        });
-        enterpriseAddressMapper.insert(dbEnterpriseAddress);
-        // 测试 enterpriseId 不匹配
-        enterpriseAddressMapper.insert(cloneIgnoreId(dbEnterpriseAddress, o -> o.setEnterpriseId(null)));
-        // 测试 address 不匹配
-        enterpriseAddressMapper.insert(cloneIgnoreId(dbEnterpriseAddress, o -> o.setAddress(null)));
-        // 测试 createTime 不匹配
-        enterpriseAddressMapper.insert(cloneIgnoreId(dbEnterpriseAddress, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterpriseAddressPageReqVO reqVO = new EnterpriseAddressPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setAddress(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseAddressDO> pageResult = enterpriseAddressService.getEnterpriseAddressPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterpriseAddress, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseBusinessServiceImplTest.java

@@ -1,179 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-
-import com.citu.module.menduner.system.controller.base.enterprise.business.EnterpriseBusinessPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.business.EnterpriseBusinessSaveReqVO;
-import com.citu.module.menduner.system.service.enterprise.business.EnterpriseBusinessServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseBusinessDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseBusinessMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import java.time.LocalDateTime;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_ENTERPRISE_BUSINESS_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseBusinessServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseBusinessServiceImpl.class)
-public class EnterpriseBusinessServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseBusinessServiceImpl enterpriseBusinessService;
-
-    @Resource
-    private EnterpriseBusinessMapper enterpriseBusinessMapper;
-
-    @Test
-    public void testCreateEnterpriseBusiness_success() {
-        // 准备参数
-        EnterpriseBusinessSaveReqVO createReqVO = randomPojo(EnterpriseBusinessSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseBusinessId = enterpriseBusinessService.createEnterpriseBusiness(createReqVO);
-        // 断言
-        assertNotNull(enterpriseBusinessId);
-        // 校验记录的属性是否正确
-        EnterpriseBusinessDO enterpriseBusiness = enterpriseBusinessMapper.selectById(enterpriseBusinessId);
-        assertPojoEquals(createReqVO, enterpriseBusiness, "id");
-    }
-
-    @Test
-    public void testUpdateEnterpriseBusiness_success() {
-        // mock 数据
-        EnterpriseBusinessDO dbEnterpriseBusiness = randomPojo(EnterpriseBusinessDO.class);
-        enterpriseBusinessMapper.insert(dbEnterpriseBusiness);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseBusinessSaveReqVO updateReqVO = randomPojo(EnterpriseBusinessSaveReqVO.class, o -> {
-            o.setId(dbEnterpriseBusiness.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseBusinessService.updateEnterpriseBusiness(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseBusinessDO enterpriseBusiness = enterpriseBusinessMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterpriseBusiness);
-    }
-
-    @Test
-    public void testUpdateEnterpriseBusiness_notExists() {
-        // 准备参数
-        EnterpriseBusinessSaveReqVO updateReqVO = randomPojo(EnterpriseBusinessSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseBusinessService.updateEnterpriseBusiness(updateReqVO), MDE_ENTERPRISE_BUSINESS_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterpriseBusiness_success() {
-        // mock 数据
-        EnterpriseBusinessDO dbEnterpriseBusiness = randomPojo(EnterpriseBusinessDO.class);
-        enterpriseBusinessMapper.insert(dbEnterpriseBusiness);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterpriseBusiness.getId();
-
-        // 调用
-        enterpriseBusinessService.deleteEnterpriseBusiness(id);
-        // 校验数据不存在了
-        assertNull(enterpriseBusinessMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterpriseBusiness_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseBusinessService.deleteEnterpriseBusiness(id), MDE_ENTERPRISE_BUSINESS_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterpriseBusinessPage() {
-        // mock 数据
-        EnterpriseBusinessDO dbEnterpriseBusiness = randomPojo(EnterpriseBusinessDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setCode(null);
-            o.setName(null);
-            o.setType(null);
-            o.setArea(null);
-            o.setAddress(null);
-            o.setRepresentative(null);
-            o.setEstablishmentTime(null);
-            o.setApprovalTime(null);
-            o.setFormerName(null);
-            o.setIndustry(null);
-            o.setRegistrationAuthority(null);
-            o.setBusinessStatus(null);
-            o.setCreateTime(null);
-        });
-        enterpriseBusinessMapper.insert(dbEnterpriseBusiness);
-        // 测试 enterpriseId 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setEnterpriseId(null)));
-        // 测试 code 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setCode(null)));
-        // 测试 name 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setName(null)));
-        // 测试 type 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setType(null)));
-        // 测试 area 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setArea(null)));
-        // 测试 address 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setAddress(null)));
-        // 测试 representative 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setRepresentative(null)));
-        // 测试 establishmentTime 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setEstablishmentTime(null)));
-        // 测试 approvalTime 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setApprovalTime(null)));
-        // 测试 formerName 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setFormerName(null)));
-        // 测试 industry 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setIndustry(null)));
-        // 测试 registrationAuthority 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setRegistrationAuthority(null)));
-        // 测试 businessStatus 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setBusinessStatus(null)));
-        // 测试 createTime 不匹配
-        enterpriseBusinessMapper.insert(cloneIgnoreId(dbEnterpriseBusiness, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterpriseBusinessPageReqVO reqVO = new EnterpriseBusinessPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setCode(null);
-        reqVO.setName(null);
-        reqVO.setType(null);
-        reqVO.setArea(null);
-        reqVO.setAddress(null);
-        reqVO.setRepresentative(null);
-        reqVO.setEstablishmentTime(LocalDateTime.now());
-        reqVO.setFormerName(null);
-        reqVO.setIndustry(null);
-        reqVO.setRegistrationAuthority(null);
-        reqVO.setBusinessStatus(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseBusinessDO> pageResult = enterpriseBusinessService.getEnterpriseBusinessPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterpriseBusiness, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterprisePostServiceImplTest.java

@@ -1,144 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.post.EnterprisePostPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.post.EnterprisePostSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterprisePostDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterprisePostMapper;
-import com.citu.module.menduner.system.service.enterprise.post.EnterprisePostServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.ENTERPRISE_POST_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterprisePostServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterprisePostServiceImpl.class)
-public class EnterprisePostServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterprisePostServiceImpl enterprisePostService;
-
-    @Resource
-    private EnterprisePostMapper enterprisePostMapper;
-
-    @Test
-    public void testCreateEnterprisePost_success() {
-        // 准备参数
-        EnterprisePostSaveReqVO createReqVO = randomPojo(EnterprisePostSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterprisePostId = enterprisePostService.createEnterprisePost(createReqVO);
-        // 断言
-        assertNotNull(enterprisePostId);
-        // 校验记录的属性是否正确
-        EnterprisePostDO enterprisePost = enterprisePostMapper.selectById(enterprisePostId);
-        assertPojoEquals(createReqVO, enterprisePost, "id");
-    }
-
-    @Test
-    public void testUpdateEnterprisePost_success() {
-        // mock 数据
-        EnterprisePostDO dbEnterprisePost = randomPojo(EnterprisePostDO.class);
-        enterprisePostMapper.insert(dbEnterprisePost);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterprisePostSaveReqVO updateReqVO = randomPojo(EnterprisePostSaveReqVO.class, o -> {
-            o.setId(dbEnterprisePost.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterprisePostService.updateEnterprisePost(updateReqVO);
-        // 校验是否更新正确
-        EnterprisePostDO enterprisePost = enterprisePostMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterprisePost);
-    }
-
-    @Test
-    public void testUpdateEnterprisePost_notExists() {
-        // 准备参数
-        EnterprisePostSaveReqVO updateReqVO = randomPojo(EnterprisePostSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterprisePostService.updateEnterprisePost(updateReqVO), ENTERPRISE_POST_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterprisePost_success() {
-        // mock 数据
-        EnterprisePostDO dbEnterprisePost = randomPojo(EnterprisePostDO.class);
-        enterprisePostMapper.insert(dbEnterprisePost);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterprisePost.getId();
-
-        // 调用
-        enterprisePostService.deleteEnterprisePost(id);
-        // 校验数据不存在了
-        assertNull(enterprisePostMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterprisePost_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterprisePostService.deleteEnterprisePost(id), ENTERPRISE_POST_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterprisePostPage() {
-        // mock 数据
-        EnterprisePostDO dbEnterprisePost = randomPojo(EnterprisePostDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setCode(null);
-            o.setNameCn(null);
-            o.setNameEn(null);
-            o.setStatus(null);
-            o.setCreateTime(null);
-        });
-        enterprisePostMapper.insert(dbEnterprisePost);
-        // 测试 enterpriseId 不匹配
-        enterprisePostMapper.insert(cloneIgnoreId(dbEnterprisePost, o -> o.setEnterpriseId(null)));
-        // 测试 code 不匹配
-        enterprisePostMapper.insert(cloneIgnoreId(dbEnterprisePost, o -> o.setCode(null)));
-        // 测试 nameCn 不匹配
-        enterprisePostMapper.insert(cloneIgnoreId(dbEnterprisePost, o -> o.setNameCn(null)));
-        // 测试 nameEn 不匹配
-        enterprisePostMapper.insert(cloneIgnoreId(dbEnterprisePost, o -> o.setNameEn(null)));
-        // 测试 status 不匹配
-        enterprisePostMapper.insert(cloneIgnoreId(dbEnterprisePost, o -> o.setStatus(null)));
-        // 测试 createTime 不匹配
-        enterprisePostMapper.insert(cloneIgnoreId(dbEnterprisePost, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterprisePostPageReqVO reqVO = new EnterprisePostPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setCode(null);
-        reqVO.setNameCn(null);
-        reqVO.setNameEn(null);
-        reqVO.setStatus(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterprisePostDO> pageResult = enterprisePostService.getEnterprisePostPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterprisePost, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseRegisterServiceImplTest.java

@@ -1,144 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.register.EnterpriseRegisterPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.register.EnterpriseRegisterSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseRegisterDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseRegisterMapper;
-import com.citu.module.menduner.system.service.enterprise.register.EnterpriseRegisterServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_ENTERPRISE_REGISTER_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseRegisterServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseRegisterServiceImpl.class)
-public class EnterpriseRegisterServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseRegisterServiceImpl enterpriseRegisterService;
-
-    @Resource
-    private EnterpriseRegisterMapper enterpriseRegisterMapper;
-
-    @Test
-    public void testCreateEnterpriseRegister_success() {
-        // 准备参数
-        EnterpriseRegisterSaveReqVO createReqVO = randomPojo(EnterpriseRegisterSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseRegisterId = enterpriseRegisterService.createEnterpriseRegister(createReqVO);
-        // 断言
-        assertNotNull(enterpriseRegisterId);
-        // 校验记录的属性是否正确
-        EnterpriseRegisterDO enterpriseRegister = enterpriseRegisterMapper.selectById(enterpriseRegisterId);
-        assertPojoEquals(createReqVO, enterpriseRegister, "id");
-    }
-
-    @Test
-    public void testUpdateEnterpriseRegister_success() {
-        // mock 数据
-        EnterpriseRegisterDO dbEnterpriseRegister = randomPojo(EnterpriseRegisterDO.class);
-        enterpriseRegisterMapper.insert(dbEnterpriseRegister);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseRegisterSaveReqVO updateReqVO = randomPojo(EnterpriseRegisterSaveReqVO.class, o -> {
-            o.setId(dbEnterpriseRegister.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseRegisterService.updateEnterpriseRegister(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseRegisterDO enterpriseRegister = enterpriseRegisterMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterpriseRegister);
-    }
-
-    @Test
-    public void testUpdateEnterpriseRegister_notExists() {
-        // 准备参数
-        EnterpriseRegisterSaveReqVO updateReqVO = randomPojo(EnterpriseRegisterSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseRegisterService.updateEnterpriseRegister(updateReqVO), MDE_ENTERPRISE_REGISTER_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterpriseRegister_success() {
-        // mock 数据
-        EnterpriseRegisterDO dbEnterpriseRegister = randomPojo(EnterpriseRegisterDO.class);
-        enterpriseRegisterMapper.insert(dbEnterpriseRegister);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterpriseRegister.getId();
-
-        // 调用
-        enterpriseRegisterService.deleteEnterpriseRegister(id);
-        // 校验数据不存在了
-        assertNull(enterpriseRegisterMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterpriseRegister_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseRegisterService.deleteEnterpriseRegister(id), MDE_ENTERPRISE_REGISTER_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterpriseRegisterPage() {
-        // mock 数据
-        EnterpriseRegisterDO dbEnterpriseRegister = randomPojo(EnterpriseRegisterDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setName(null);
-            o.setPhone(null);
-            o.setEmail(null);
-            o.setStatus(null);
-            o.setCreateTime(null);
-        });
-        enterpriseRegisterMapper.insert(dbEnterpriseRegister);
-        // 测试 userId 不匹配
-        enterpriseRegisterMapper.insert(cloneIgnoreId(dbEnterpriseRegister, o -> o.setUserId(null)));
-        // 测试 name 不匹配
-        enterpriseRegisterMapper.insert(cloneIgnoreId(dbEnterpriseRegister, o -> o.setName(null)));
-        // 测试 phone 不匹配
-        enterpriseRegisterMapper.insert(cloneIgnoreId(dbEnterpriseRegister, o -> o.setPhone(null)));
-        // 测试 email 不匹配
-        enterpriseRegisterMapper.insert(cloneIgnoreId(dbEnterpriseRegister, o -> o.setEmail(null)));
-        // 测试 status 不匹配
-        enterpriseRegisterMapper.insert(cloneIgnoreId(dbEnterpriseRegister, o -> o.setStatus(null)));
-        // 测试 createTime 不匹配
-        enterpriseRegisterMapper.insert(cloneIgnoreId(dbEnterpriseRegister, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterpriseRegisterPageReqVO reqVO = new EnterpriseRegisterPageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setName(null);
-        reqVO.setPhone(null);
-        reqVO.setEmail(null);
-        reqVO.setStatus(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseRegisterDO> pageResult = enterpriseRegisterService.getEnterpriseRegisterPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterpriseRegister, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseServiceImplTest.java

@@ -1,152 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.vo.EnterprisePageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.vo.EnterpriseSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_ENTERPRISE_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseServiceImpl.class)
-public class EnterpriseServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseServiceImpl enterpriseService;
-
-    @Resource
-    private EnterpriseMapper enterpriseMapper;
-
-    @Test
-    public void testCreateEnterprise_success() {
-        // 准备参数
-        EnterpriseSaveReqVO createReqVO = randomPojo(EnterpriseSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseId = enterpriseService.createEnterprise(createReqVO);
-        // 断言
-        assertNotNull(enterpriseId);
-        // 校验记录的属性是否正确
-        EnterpriseDO enterprise = enterpriseMapper.selectById(enterpriseId);
-        assertPojoEquals(createReqVO, enterprise, "id");
-    }
-
-    @Test
-    public void testUpdateEnterprise_success() {
-        // mock 数据
-        EnterpriseDO dbEnterprise = randomPojo(EnterpriseDO.class);
-        enterpriseMapper.insert(dbEnterprise);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseSaveReqVO updateReqVO = randomPojo(EnterpriseSaveReqVO.class, o -> {
-            o.setId(dbEnterprise.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseService.updateEnterprise(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseDO enterprise = enterpriseMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterprise);
-    }
-
-    @Test
-    public void testUpdateEnterprise_notExists() {
-        // 准备参数
-        EnterpriseSaveReqVO updateReqVO = randomPojo(EnterpriseSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseService.updateEnterprise(updateReqVO), MDE_ENTERPRISE_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterprise_success() {
-        // mock 数据
-        EnterpriseDO dbEnterprise = randomPojo(EnterpriseDO.class);
-        enterpriseMapper.insert(dbEnterprise);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterprise.getId();
-
-        // 调用
-        enterpriseService.deleteEnterprise(id);
-        // 校验数据不存在了
-        assertNull(enterpriseMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterprise_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseService.deleteEnterprise(id), MDE_ENTERPRISE_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterprisePage() {
-        // mock 数据
-        EnterpriseDO dbEnterprise = randomPojo(EnterpriseDO.class, o -> { // 等会查询到
-            o.setName(null);
-            o.setAnotherName(null);
-            o.setContact(null);
-            o.setPhone(null);
-            o.setIndustryId(null);
-            o.setFinancingStatus(null);
-            o.setScale(null);
-            o.setCreateTime(null);
-        });
-        enterpriseMapper.insert(dbEnterprise);
-        // 测试 name 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setName(null)));
-        // 测试 anotherName 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setAnotherName(null)));
-        // 测试 contact 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setContact(null)));
-        // 测试 phone 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setPhone(null)));
-        // 测试 industryId 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setIndustryId(null)));
-        // 测试 financingStatus 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setFinancingStatus(null)));
-        // 测试 scale 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setScale(null)));
-        // 测试 createTime 不匹配
-        enterpriseMapper.insert(cloneIgnoreId(dbEnterprise, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterprisePageReqVO reqVO = new EnterprisePageReqVO();
-        reqVO.setName(null);
-        reqVO.setAnotherName(null);
-        reqVO.setContact(null);
-        reqVO.setPhone(null);
-        reqVO.setIndustryId(null);
-        reqVO.setFinancingStatus(null);
-        reqVO.setScale(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseDO> pageResult = enterpriseService.getEnterprisePage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterprise, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseUserApplyServiceImplTest.java

@@ -1,144 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.user.EnterpriseUserApplyPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.user.EnterpriseUserApplySaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseUserApplyDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseUserApplyMapper;
-import com.citu.module.menduner.system.service.enterprise.user.EnterpriseUserApplyServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.ENTERPRISE_USER_APPLY_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseUserApplyServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseUserApplyServiceImpl.class)
-public class EnterpriseUserApplyServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseUserApplyServiceImpl enterpriseUserApplyService;
-
-    @Resource
-    private EnterpriseUserApplyMapper enterpriseUserApplyMapper;
-
-    @Test
-    public void testCreateEnterpriseUserApply_success() {
-        // 准备参数
-        EnterpriseUserApplySaveReqVO createReqVO = randomPojo(EnterpriseUserApplySaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseUserApplyId = enterpriseUserApplyService.createEnterpriseUserApply(createReqVO);
-        // 断言
-        assertNotNull(enterpriseUserApplyId);
-        // 校验记录的属性是否正确
-        EnterpriseUserApplyDO enterpriseUserApply = enterpriseUserApplyMapper.selectById(enterpriseUserApplyId);
-        assertPojoEquals(createReqVO, enterpriseUserApply, "id");
-    }
-
-    @Test
-    public void testUpdateEnterpriseUserApply_success() {
-        // mock 数据
-        EnterpriseUserApplyDO dbEnterpriseUserApply = randomPojo(EnterpriseUserApplyDO.class);
-        enterpriseUserApplyMapper.insert(dbEnterpriseUserApply);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseUserApplySaveReqVO updateReqVO = randomPojo(EnterpriseUserApplySaveReqVO.class, o -> {
-            o.setId(dbEnterpriseUserApply.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseUserApplyService.updateEnterpriseUserApply(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseUserApplyDO enterpriseUserApply = enterpriseUserApplyMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterpriseUserApply);
-    }
-
-    @Test
-    public void testUpdateEnterpriseUserApply_notExists() {
-        // 准备参数
-        EnterpriseUserApplySaveReqVO updateReqVO = randomPojo(EnterpriseUserApplySaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseUserApplyService.updateEnterpriseUserApply(updateReqVO), ENTERPRISE_USER_APPLY_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterpriseUserApply_success() {
-        // mock 数据
-        EnterpriseUserApplyDO dbEnterpriseUserApply = randomPojo(EnterpriseUserApplyDO.class);
-        enterpriseUserApplyMapper.insert(dbEnterpriseUserApply);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterpriseUserApply.getId();
-
-        // 调用
-        enterpriseUserApplyService.deleteEnterpriseUserApply(id);
-        // 校验数据不存在了
-        assertNull(enterpriseUserApplyMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterpriseUserApply_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseUserApplyService.deleteEnterpriseUserApply(id), ENTERPRISE_USER_APPLY_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterpriseUserApplyPage() {
-        // mock 数据
-        EnterpriseUserApplyDO dbEnterpriseUserApply = randomPojo(EnterpriseUserApplyDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setEnterpriseId(null);
-            o.setPostId(null);
-            o.setName(null);
-            o.setStatus(null);
-            o.setCreateTime(null);
-        });
-        enterpriseUserApplyMapper.insert(dbEnterpriseUserApply);
-        // 测试 userId 不匹配
-        enterpriseUserApplyMapper.insert(cloneIgnoreId(dbEnterpriseUserApply, o -> o.setUserId(null)));
-        // 测试 enterpriseId 不匹配
-        enterpriseUserApplyMapper.insert(cloneIgnoreId(dbEnterpriseUserApply, o -> o.setEnterpriseId(null)));
-        // 测试 postId 不匹配
-        enterpriseUserApplyMapper.insert(cloneIgnoreId(dbEnterpriseUserApply, o -> o.setPostId(null)));
-        // 测试 name 不匹配
-        enterpriseUserApplyMapper.insert(cloneIgnoreId(dbEnterpriseUserApply, o -> o.setName(null)));
-        // 测试 status 不匹配
-        enterpriseUserApplyMapper.insert(cloneIgnoreId(dbEnterpriseUserApply, o -> o.setStatus(null)));
-        // 测试 createTime 不匹配
-        enterpriseUserApplyMapper.insert(cloneIgnoreId(dbEnterpriseUserApply, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterpriseUserApplyPageReqVO reqVO = new EnterpriseUserApplyPageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setEnterpriseId(null);
-        reqVO.setPostId(null);
-        reqVO.setName(null);
-        reqVO.setStatus(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseUserApplyDO> pageResult = enterpriseUserApplyService.getEnterpriseUserApplyPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterpriseUserApply, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseUserBindServiceImplTest.java

@@ -1,141 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.bind.EnterpriseUserBindPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.bind.EnterpriseUserBindSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseUserBindDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseUserBindMapper;
-import com.citu.module.menduner.system.service.enterprise.bind.EnterpriseUserBindServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_ENTERPRISE_USER_BIND_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseUserBindServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseUserBindServiceImpl.class)
-public class EnterpriseUserBindServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseUserBindServiceImpl enterpriseUserBindService;
-
-    @Resource
-    private EnterpriseUserBindMapper enterpriseUserBindMapper;
-
-    @Test
-    public void testCreateEnterpriseUserBind_success() {
-        // 准备参数
-        EnterpriseUserBindSaveReqVO createReqVO = randomPojo(EnterpriseUserBindSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseUserBindId = enterpriseUserBindService.createEnterpriseUserBind(createReqVO);
-        // 断言
-        assertNotNull(enterpriseUserBindId);
-        // 校验记录的属性是否正确
-        EnterpriseUserBindDO enterpriseUserBind = enterpriseUserBindMapper.selectById(enterpriseUserBindId);
-        assertPojoEquals(createReqVO, enterpriseUserBind, "id");
-    }
-
-    @Test
-    public void testUpdateEnterpriseUserBind_success() {
-        // mock 数据
-        EnterpriseUserBindDO dbEnterpriseUserBind = randomPojo(EnterpriseUserBindDO.class);
-        enterpriseUserBindMapper.insert(dbEnterpriseUserBind);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseUserBindSaveReqVO updateReqVO = randomPojo(EnterpriseUserBindSaveReqVO.class, o -> {
-            o.setId(dbEnterpriseUserBind.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseUserBindService.updateEnterpriseUserBind(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseUserBindDO enterpriseUserBind = enterpriseUserBindMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterpriseUserBind);
-    }
-
-    @Test
-    public void testUpdateEnterpriseUserBind_notExists() {
-        // 准备参数
-        EnterpriseUserBindSaveReqVO updateReqVO = randomPojo(EnterpriseUserBindSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseUserBindService.updateEnterpriseUserBind(updateReqVO), MDE_ENTERPRISE_USER_BIND_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterpriseUserBind_success() {
-        // mock 数据
-        EnterpriseUserBindDO dbEnterpriseUserBind = randomPojo(EnterpriseUserBindDO.class);
-        enterpriseUserBindMapper.insert(dbEnterpriseUserBind);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterpriseUserBind.getId();
-
-        // 调用
-        enterpriseUserBindService.deleteEnterpriseUserBind(id);
-        // 校验数据不存在了
-        assertNull(enterpriseUserBindMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterpriseUserBind_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseUserBindService.deleteEnterpriseUserBind(id), MDE_ENTERPRISE_USER_BIND_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterpriseUserBindPage() {
-        // mock 数据
-        EnterpriseUserBindDO dbEnterpriseUserBind = randomPojo(EnterpriseUserBindDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setUserId(null);
-            o.setStatus(null);
-            o.setLoginIp(null);
-            o.setCreateTime(null);
-        });
-        enterpriseUserBindMapper.insert(dbEnterpriseUserBind);
-        // 测试 enterpriseId 不匹配
-        enterpriseUserBindMapper.insert(cloneIgnoreId(dbEnterpriseUserBind, o -> o.setEnterpriseId(null)));
-        // 测试 userId 不匹配
-        enterpriseUserBindMapper.insert(cloneIgnoreId(dbEnterpriseUserBind, o -> o.setUserId(null)));
-        // 测试 status 不匹配
-        enterpriseUserBindMapper.insert(cloneIgnoreId(dbEnterpriseUserBind, o -> o.setStatus(null)));
-        // 测试 loginIp 不匹配
-        enterpriseUserBindMapper.insert(cloneIgnoreId(dbEnterpriseUserBind, o -> o.setLoginIp(null)));
-        // 测试 createTime 不匹配
-        enterpriseUserBindMapper.insert(cloneIgnoreId(dbEnterpriseUserBind, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterpriseUserBindPageReqVO reqVO = new EnterpriseUserBindPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setUserId(null);
-        reqVO.setStatus(null);
-        reqVO.setLoginIp(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseUserBindDO> pageResult = enterpriseUserBindService.getEnterpriseUserBindPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterpriseUserBind, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/enterprise/EnterpriseUserLookServiceImplTest.java

@@ -1,144 +0,0 @@
-package com.citu.module.menduner.system.service.enterprise;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.enterprise.look.EnterpriseUserLookPageReqVO;
-import com.citu.module.menduner.system.controller.base.enterprise.look.EnterpriseUserLookSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.enterprise.EnterpriseUserLookDO;
-import com.citu.module.menduner.system.dal.mysql.enterprise.EnterpriseUserLookMapper;
-import com.citu.module.menduner.system.service.enterprise.look.EnterpriseUserLookServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.ENTERPRISE_USER_LOOK_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link EnterpriseUserLookServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(EnterpriseUserLookServiceImpl.class)
-public class EnterpriseUserLookServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private EnterpriseUserLookServiceImpl enterpriseUserLookService;
-
-    @Resource
-    private EnterpriseUserLookMapper enterpriseUserLookMapper;
-
-    @Test
-    public void testCreateEnterpriseUserLook_success() {
-        // 准备参数
-        EnterpriseUserLookSaveReqVO createReqVO = randomPojo(EnterpriseUserLookSaveReqVO.class).setId(null);
-
-        // 调用
-        Long enterpriseUserLookId = enterpriseUserLookService.createEnterpriseUserLook(createReqVO);
-        // 断言
-        assertNotNull(enterpriseUserLookId);
-        // 校验记录的属性是否正确
-        EnterpriseUserLookDO enterpriseUserLook = enterpriseUserLookMapper.selectById(enterpriseUserLookId);
-        assertPojoEquals(createReqVO, enterpriseUserLook, "id");
-    }
-
-    @Test
-    public void testUpdateEnterpriseUserLook_success() {
-        // mock 数据
-        EnterpriseUserLookDO dbEnterpriseUserLook = randomPojo(EnterpriseUserLookDO.class);
-        enterpriseUserLookMapper.insert(dbEnterpriseUserLook);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        EnterpriseUserLookSaveReqVO updateReqVO = randomPojo(EnterpriseUserLookSaveReqVO.class, o -> {
-            o.setId(dbEnterpriseUserLook.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        enterpriseUserLookService.updateEnterpriseUserLook(updateReqVO);
-        // 校验是否更新正确
-        EnterpriseUserLookDO enterpriseUserLook = enterpriseUserLookMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, enterpriseUserLook);
-    }
-
-    @Test
-    public void testUpdateEnterpriseUserLook_notExists() {
-        // 准备参数
-        EnterpriseUserLookSaveReqVO updateReqVO = randomPojo(EnterpriseUserLookSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseUserLookService.updateEnterpriseUserLook(updateReqVO), ENTERPRISE_USER_LOOK_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteEnterpriseUserLook_success() {
-        // mock 数据
-        EnterpriseUserLookDO dbEnterpriseUserLook = randomPojo(EnterpriseUserLookDO.class);
-        enterpriseUserLookMapper.insert(dbEnterpriseUserLook);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbEnterpriseUserLook.getId();
-
-        // 调用
-        enterpriseUserLookService.deleteEnterpriseUserLook(id);
-        // 校验数据不存在了
-        assertNull(enterpriseUserLookMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteEnterpriseUserLook_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> enterpriseUserLookService.deleteEnterpriseUserLook(id), ENTERPRISE_USER_LOOK_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetEnterpriseUserLookPage() {
-        // mock 数据
-        EnterpriseUserLookDO dbEnterpriseUserLook = randomPojo(EnterpriseUserLookDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setUserId(null);
-            o.setUserName(null);
-            o.setUserPostName(null);
-            o.setLookUserId(null);
-            o.setCreateTime(null);
-        });
-        enterpriseUserLookMapper.insert(dbEnterpriseUserLook);
-        // 测试 enterpriseId 不匹配
-        enterpriseUserLookMapper.insert(cloneIgnoreId(dbEnterpriseUserLook, o -> o.setEnterpriseId(null)));
-        // 测试 userId 不匹配
-        enterpriseUserLookMapper.insert(cloneIgnoreId(dbEnterpriseUserLook, o -> o.setUserId(null)));
-        // 测试 userName 不匹配
-        enterpriseUserLookMapper.insert(cloneIgnoreId(dbEnterpriseUserLook, o -> o.setUserName(null)));
-        // 测试 userPostName 不匹配
-        enterpriseUserLookMapper.insert(cloneIgnoreId(dbEnterpriseUserLook, o -> o.setUserPostName(null)));
-        // 测试 lookUserId 不匹配
-        enterpriseUserLookMapper.insert(cloneIgnoreId(dbEnterpriseUserLook, o -> o.setLookUserId(null)));
-        // 测试 createTime 不匹配
-        enterpriseUserLookMapper.insert(cloneIgnoreId(dbEnterpriseUserLook, o -> o.setCreateTime(null)));
-        // 准备参数
-        EnterpriseUserLookPageReqVO reqVO = new EnterpriseUserLookPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setUserId(null);
-        reqVO.setUserName(null);
-        reqVO.setUserPostName(null);
-        reqVO.setLookUserId(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<EnterpriseUserLookDO> pageResult = enterpriseUserLookService.getEnterpriseUserLookPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbEnterpriseUserLook, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/hire/HireCommissionRatioServiceImplTest.java

@@ -1,132 +0,0 @@
-package com.citu.module.menduner.system.service.hire;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.hire.HireCommissionRatioPageReqVO;
-import com.citu.module.menduner.system.controller.base.hire.HireCommissionRatioSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.hire.HireCommissionRatioDO;
-import com.citu.module.menduner.system.dal.mysql.hire.HireCommissionRatioMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.HIRE_COMMISSION_RATIO_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link HireCommissionRatioServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(HireCommissionRatioServiceImpl.class)
-public class HireCommissionRatioServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private HireCommissionRatioServiceImpl hireCommissionRatioService;
-
-    @Resource
-    private HireCommissionRatioMapper hireCommissionRatioMapper;
-
-    @Test
-    public void testCreateHireCommissionRatio_success() {
-        // 准备参数
-        HireCommissionRatioSaveReqVO createReqVO = randomPojo(HireCommissionRatioSaveReqVO.class).setId(null);
-
-        // 调用
-        Long hireCommissionRatioId = hireCommissionRatioService.createHireCommissionRatio(createReqVO);
-        // 断言
-        assertNotNull(hireCommissionRatioId);
-        // 校验记录的属性是否正确
-        HireCommissionRatioDO hireCommissionRatio = hireCommissionRatioMapper.selectById(hireCommissionRatioId);
-        assertPojoEquals(createReqVO, hireCommissionRatio, "id");
-    }
-
-    @Test
-    public void testUpdateHireCommissionRatio_success() {
-        // mock 数据
-        HireCommissionRatioDO dbHireCommissionRatio = randomPojo(HireCommissionRatioDO.class);
-        hireCommissionRatioMapper.insert(dbHireCommissionRatio);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        HireCommissionRatioSaveReqVO updateReqVO = randomPojo(HireCommissionRatioSaveReqVO.class, o -> {
-            o.setId(dbHireCommissionRatio.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        hireCommissionRatioService.updateHireCommissionRatio(updateReqVO);
-        // 校验是否更新正确
-        HireCommissionRatioDO hireCommissionRatio = hireCommissionRatioMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, hireCommissionRatio);
-    }
-
-    @Test
-    public void testUpdateHireCommissionRatio_notExists() {
-        // 准备参数
-        HireCommissionRatioSaveReqVO updateReqVO = randomPojo(HireCommissionRatioSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> hireCommissionRatioService.updateHireCommissionRatio(updateReqVO), HIRE_COMMISSION_RATIO_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteHireCommissionRatio_success() {
-        // mock 数据
-        HireCommissionRatioDO dbHireCommissionRatio = randomPojo(HireCommissionRatioDO.class);
-        hireCommissionRatioMapper.insert(dbHireCommissionRatio);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbHireCommissionRatio.getId();
-
-        // 调用
-        hireCommissionRatioService.deleteHireCommissionRatio(id);
-        // 校验数据不存在了
-        assertNull(hireCommissionRatioMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteHireCommissionRatio_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> hireCommissionRatioService.deleteHireCommissionRatio(id), HIRE_COMMISSION_RATIO_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetHireCommissionRatioPage() {
-        // mock 数据
-        HireCommissionRatioDO dbHireCommissionRatio = randomPojo(HireCommissionRatioDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setUserId(null);
-            o.setCreateTime(null);
-        });
-        hireCommissionRatioMapper.insert(dbHireCommissionRatio);
-        // 测试 enterpriseId 不匹配
-        hireCommissionRatioMapper.insert(cloneIgnoreId(dbHireCommissionRatio, o -> o.setEnterpriseId(null)));
-        // 测试 userId 不匹配
-        hireCommissionRatioMapper.insert(cloneIgnoreId(dbHireCommissionRatio, o -> o.setUserId(null)));
-        // 测试 createTime 不匹配
-        hireCommissionRatioMapper.insert(cloneIgnoreId(dbHireCommissionRatio, o -> o.setCreateTime(null)));
-        // 准备参数
-        HireCommissionRatioPageReqVO reqVO = new HireCommissionRatioPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setUserId(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<HireCommissionRatioDO> pageResult = hireCommissionRatioService.getHireCommissionRatioPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbHireCommissionRatio, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/hire/HireJobCvRelServiceImplTest.java

@@ -1,160 +0,0 @@
-//package com.citu.module.menduner.system.service.hire;
-//
-//
-//import com.citu.framework.common.pojo.PageResult;
-//import com.citu.framework.test.core.ut.BaseDbUnitTest;
-//import com.citu.module.menduner.system.controller.base.hire.HireJobCvRelPageReqVO;
-//import com.citu.module.menduner.system.controller.base.hire.HireJobCvRelSaveReqVO;
-//import com.citu.module.menduner.system.dal.dataobject.hire.HireJobCvRelDO;
-//import com.citu.module.menduner.system.dal.mysql.hire.HireJobCvRelMapper;
-//import org.junit.jupiter.api.Disabled;
-//import org.junit.jupiter.api.Test;
-//import org.springframework.context.annotation.Import;
-//
-//import javax.annotation.Resource;
-//
-//import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-//import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-//import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-//import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-//import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-//import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-//import static com.citu.module.menduner.system.enums.ErrorCodeConstants.HIRE_JOB_CV_REL_NOT_EXISTS;
-//import static org.junit.jupiter.api.Assertions.*;
-//
-///**
-// * {@link HireJobCvRelServiceImpl} 的单元测试类
-// *
-// * @author Rayson
-// */
-//@Import(HireJobCvRelServiceImpl.class)
-//public class HireJobCvRelServiceImplTest extends BaseDbUnitTest {
-//
-//    @Resource
-//    private HireJobCvRelServiceImpl hireJobCvRelService;
-//
-//    @Resource
-//    private HireJobCvRelMapper hireJobCvRelMapper;
-//
-//    @Test
-//    public void testCreateHireJobCvRel_success() {
-//        // 准备参数
-//        HireJobCvRelSaveReqVO createReqVO = randomPojo(HireJobCvRelSaveReqVO.class).setId(null);
-//
-//        // 调用
-//        Long hireJobCvRelId = hireJobCvRelService.createHireJobCvRel(createReqVO);
-//        // 断言
-//        assertNotNull(hireJobCvRelId);
-//        // 校验记录的属性是否正确
-//        HireJobCvRelDO hireJobCvRel = hireJobCvRelMapper.selectById(hireJobCvRelId);
-//        assertPojoEquals(createReqVO, hireJobCvRel, "id");
-//    }
-//
-//    @Test
-//    public void testUpdateHireJobCvRel_success() {
-//        // mock 数据
-//        HireJobCvRelDO dbHireJobCvRel = randomPojo(HireJobCvRelDO.class);
-//        hireJobCvRelMapper.insert(dbHireJobCvRel);// @Sql: 先插入出一条存在的数据
-//        // 准备参数
-//        HireJobCvRelSaveReqVO updateReqVO = randomPojo(HireJobCvRelSaveReqVO.class, o -> {
-//            o.setId(dbHireJobCvRel.getId()); // 设置更新的 ID
-//        });
-//
-//        // 调用
-//        hireJobCvRelService.updateHireJobCvRel(updateReqVO);
-//        // 校验是否更新正确
-//        HireJobCvRelDO hireJobCvRel = hireJobCvRelMapper.selectById(updateReqVO.getId()); // 获取最新的
-//        assertPojoEquals(updateReqVO, hireJobCvRel);
-//    }
-//
-//    @Test
-//    public void testUpdateHireJobCvRel_notExists() {
-//        // 准备参数
-//        HireJobCvRelSaveReqVO updateReqVO = randomPojo(HireJobCvRelSaveReqVO.class);
-//
-//        // 调用, 并断言异常
-//        assertServiceException(() -> hireJobCvRelService.updateHireJobCvRel(updateReqVO), HIRE_JOB_CV_REL_NOT_EXISTS);
-//    }
-//
-//    @Test
-//    public void testDeleteHireJobCvRel_success() {
-//        // mock 数据
-//        HireJobCvRelDO dbHireJobCvRel = randomPojo(HireJobCvRelDO.class);
-//        hireJobCvRelMapper.insert(dbHireJobCvRel);// @Sql: 先插入出一条存在的数据
-//        // 准备参数
-//        Long id = dbHireJobCvRel.getId();
-//
-//        // 调用
-//        hireJobCvRelService.deleteHireJobCvRel(id);
-//        // 校验数据不存在了
-//        assertNull(hireJobCvRelMapper.selectById(id));
-//    }
-//
-//    @Test
-//    public void testDeleteHireJobCvRel_notExists() {
-//        // 准备参数
-//        Long id = randomLongId();
-//
-//        // 调用, 并断言异常
-//        assertServiceException(() -> hireJobCvRelService.deleteHireJobCvRel(id), HIRE_JOB_CV_REL_NOT_EXISTS);
-//    }
-//
-//    @Test
-//    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-//    public void testGetHireJobCvRelPage() {
-//        // mock 数据
-//        HireJobCvRelDO dbHireJobCvRel = randomPojo(HireJobCvRelDO.class, o -> { // 等会查询到
-//            o.setEnterpriseId(null);
-//            o.setJobId(null);
-//            o.setPublishUserId(null);
-//            o.setRecommendUserId(null);
-//            o.setUserId(null);
-//            o.setName(null);
-//            o.setPhone(null);
-//            o.setUrl(null);
-//            o.setStatus(null);
-//            o.setCreateTime(null);
-//        });
-//        hireJobCvRelMapper.insert(dbHireJobCvRel);
-//        // 测试 enterpriseId 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setEnterpriseId(null)));
-//        // 测试 jobId 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setJobId(null)));
-//        // 测试 publishUserId 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setPublishUserId(null)));
-//        // 测试 recommendUserId 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setRecommendUserId(null)));
-//        // 测试 userId 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setUserId(null)));
-//        // 测试 name 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setName(null)));
-//        // 测试 phone 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setPhone(null)));
-//        // 测试 url 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setUrl(null)));
-//        // 测试 status 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setStatus(null)));
-//        // 测试 createTime 不匹配
-//        hireJobCvRelMapper.insert(cloneIgnoreId(dbHireJobCvRel, o -> o.setCreateTime(null)));
-//        // 准备参数
-//        HireJobCvRelPageReqVO reqVO = new HireJobCvRelPageReqVO();
-//        reqVO.setEnterpriseId(null);
-//        reqVO.setJobId(null);
-//        reqVO.setPublishUserId(null);
-//        reqVO.setRecommendUserId(null);
-//        reqVO.setUserId(null);
-//        reqVO.setName(null);
-//        reqVO.setPhone(null);
-//        reqVO.setUrl(null);
-//        reqVO.setStatus(null);
-//        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-//
-//        // 调用
-//        PageResult<HireJobCvRelDO> pageResult = hireJobCvRelService.getHireJobCvRelPage(reqVO);
-//        // 断言
-//        assertEquals(1, pageResult.getTotal());
-//        assertEquals(1, pageResult.getList().size());
-//        assertPojoEquals(dbHireJobCvRel, pageResult.getList().get(0));
-//    }
-//
-//}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/industry/IndustryServiceImplTest.java

@@ -1,133 +0,0 @@
-package com.citu.module.menduner.system.service.industry;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.industry.IndustryPageReqVO;
-import com.citu.module.menduner.system.controller.base.industry.IndustrySaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.industry.IndustryDO;
-import com.citu.module.menduner.system.dal.mysql.industry.IndustryMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_INDUSTRY_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-
-/**
- * {@link IndustryServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(IndustryServiceImpl.class)
-public class IndustryServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private IndustryServiceImpl industryService;
-
-    @Resource
-    private IndustryMapper industryMapper;
-
-    @Test
-    public void testCreateIndustry_success() {
-        // 准备参数
-        IndustrySaveReqVO createReqVO = randomPojo(IndustrySaveReqVO.class).setId(null);
-
-        // 调用
-        Long industryId = industryService.createIndustry(createReqVO);
-        // 断言
-        assertNotNull(industryId);
-        // 校验记录的属性是否正确
-        IndustryDO industry = industryMapper.selectById(industryId);
-        assertPojoEquals(createReqVO, industry, "id");
-    }
-
-    @Test
-    public void testUpdateIndustry_success() {
-        // mock 数据
-        IndustryDO dbIndustry = randomPojo(IndustryDO.class);
-        industryMapper.insert(dbIndustry);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        IndustrySaveReqVO updateReqVO = randomPojo(IndustrySaveReqVO.class, o -> {
-            o.setId(dbIndustry.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        industryService.updateIndustry(updateReqVO);
-        // 校验是否更新正确
-        IndustryDO industry = industryMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, industry);
-    }
-
-    @Test
-    public void testUpdateIndustry_notExists() {
-        // 准备参数
-        IndustrySaveReqVO updateReqVO = randomPojo(IndustrySaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> industryService.updateIndustry(updateReqVO), MDE_INDUSTRY_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteIndustry_success() {
-        // mock 数据
-        IndustryDO dbIndustry = randomPojo(IndustryDO.class);
-        industryMapper.insert(dbIndustry);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbIndustry.getId();
-
-        // 调用
-        industryService.deleteIndustry(id);
-        // 校验数据不存在了
-        assertNull(industryMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteIndustry_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> industryService.deleteIndustry(id), MDE_INDUSTRY_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetIndustryPage() {
-        // mock 数据
-        IndustryDO dbIndustry = randomPojo(IndustryDO.class, o -> { // 等会查询到
-            o.setNameCn(null);
-            o.setNameEn(null);
-            o.setCreateTime(null);
-        });
-        industryMapper.insert(dbIndustry);
-        // 测试 nameCn 不匹配
-        industryMapper.insert(cloneIgnoreId(dbIndustry, o -> o.setNameCn(null)));
-        // 测试 nameEn 不匹配
-        industryMapper.insert(cloneIgnoreId(dbIndustry, o -> o.setNameEn(null)));
-        // 测试 createTime 不匹配
-        industryMapper.insert(cloneIgnoreId(dbIndustry, o -> o.setCreateTime(null)));
-        // 准备参数
-        IndustryPageReqVO reqVO = new IndustryPageReqVO();
-        reqVO.setNameCn(null);
-        reqVO.setNameEn(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<IndustryDO> pageResult = industryService.getIndustryPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbIndustry, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/job/JobAdvertisedServiceImplTest.java

@@ -1,167 +0,0 @@
-package com.citu.module.menduner.system.service.job;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.job.JobAdvertisedPageReqVO;
-import com.citu.module.menduner.system.controller.base.job.JobAdvertisedSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.job.JobAdvertisedDO;
-import com.citu.module.menduner.system.dal.mysql.job.JobAdvertisedMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_JOB_ADVERTISED_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link JobAdvertisedServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(JobAdvertisedServiceImpl.class)
-public class JobAdvertisedServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private JobAdvertisedServiceImpl jobAdvertisedService;
-
-    @Resource
-    private JobAdvertisedMapper jobAdvertisedMapper;
-
-    @Test
-    public void testCreateJobAdvertised_success() {
-        // 准备参数
-        JobAdvertisedSaveReqVO createReqVO = randomPojo(JobAdvertisedSaveReqVO.class).setId(null);
-
-        // 调用
-        Long jobAdvertisedId = jobAdvertisedService.createJobAdvertised(createReqVO);
-        // 断言
-        assertNotNull(jobAdvertisedId);
-        // 校验记录的属性是否正确
-        JobAdvertisedDO jobAdvertised = jobAdvertisedMapper.selectById(jobAdvertisedId);
-        assertPojoEquals(createReqVO, jobAdvertised, "id");
-    }
-
-    @Test
-    public void testUpdateJobAdvertised_success() {
-        // mock 数据
-        JobAdvertisedDO dbJobAdvertised = randomPojo(JobAdvertisedDO.class);
-        jobAdvertisedMapper.insert(dbJobAdvertised);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        JobAdvertisedSaveReqVO updateReqVO = randomPojo(JobAdvertisedSaveReqVO.class, o -> {
-            o.setId(dbJobAdvertised.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        jobAdvertisedService.updateJobAdvertised(updateReqVO);
-        // 校验是否更新正确
-        JobAdvertisedDO jobAdvertised = jobAdvertisedMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, jobAdvertised);
-    }
-
-    @Test
-    public void testUpdateJobAdvertised_notExists() {
-        // 准备参数
-        JobAdvertisedSaveReqVO updateReqVO = randomPojo(JobAdvertisedSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> jobAdvertisedService.updateJobAdvertised(updateReqVO), MDE_JOB_ADVERTISED_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteJobAdvertised_success() {
-        // mock 数据
-        JobAdvertisedDO dbJobAdvertised = randomPojo(JobAdvertisedDO.class);
-        jobAdvertisedMapper.insert(dbJobAdvertised);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbJobAdvertised.getId();
-
-        // 调用
-        jobAdvertisedService.deleteJobAdvertised(id);
-        // 校验数据不存在了
-        assertNull(jobAdvertisedMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteJobAdvertised_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> jobAdvertisedService.deleteJobAdvertised(id), MDE_JOB_ADVERTISED_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetJobAdvertisedPage() {
-        // mock 数据
-        JobAdvertisedDO dbJobAdvertised = randomPojo(JobAdvertisedDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setUserId(null);
-            o.setAreaId(null);
-            o.setName(null);
-            o.setPositionId(null);
-            o.setType(null);
-            o.setExpType(null);
-            o.setEduType(null);
-            o.setContent(null);
-            o.setRequirement(null);
-            o.setStatus(null);
-            o.setCreateTime(null);
-        });
-        jobAdvertisedMapper.insert(dbJobAdvertised);
-        // 测试 enterpriseId 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setEnterpriseId(null)));
-        // 测试 userId 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setUserId(null)));
-        // 测试 areaId 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setAreaId(null)));
-        // 测试 name 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setName(null)));
-        // 测试 positionId 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setPositionId(null)));
-        // 测试 type 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setType(null)));
-        // 测试 expType 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setExpType(null)));
-        // 测试 eduType 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setEduType(null)));
-        // 测试 content 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setContent(null)));
-        // 测试 requirement 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setRequirement(null)));
-        // 测试 status 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setStatus(null)));
-        // 测试 createTime 不匹配
-        jobAdvertisedMapper.insert(cloneIgnoreId(dbJobAdvertised, o -> o.setCreateTime(null)));
-        // 准备参数
-        JobAdvertisedPageReqVO reqVO = new JobAdvertisedPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setUserId(null);
-        reqVO.setAreaId(null);
-        reqVO.setName(null);
-        reqVO.setPositionId(null);
-        reqVO.setType(null);
-        reqVO.setExpType(null);
-        reqVO.setEduType(null);
-//        reqVO.setContent(null);
-//        reqVO.setRequirement(null);
-        reqVO.setStatus(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<JobAdvertisedDO> pageResult = jobAdvertisedService.getJobAdvertisedPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbJobAdvertised, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/job/JobCvRelServiceImplTest.java

@@ -1,143 +0,0 @@
-package com.citu.module.menduner.system.service.job;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.job.JobCvRelPageReqVO;
-import com.citu.module.menduner.system.controller.base.job.JobCvRelSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.job.JobCvRelDO;
-import com.citu.module.menduner.system.dal.mysql.job.JobCvRelMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.JOB_CV_REL_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link JobCvRelServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(JobCvRelServiceImpl.class)
-public class JobCvRelServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private JobCvRelServiceImpl jobCvRelService;
-
-    @Resource
-    private JobCvRelMapper jobCvRelMapper;
-
-    @Test
-    public void testCreateJobCvRel_success() {
-        // 准备参数
-        JobCvRelSaveReqVO createReqVO = randomPojo(JobCvRelSaveReqVO.class).setId(null);
-
-        // 调用
-        Long jobCvRelId = jobCvRelService.createJobCvRel(createReqVO);
-        // 断言
-        assertNotNull(jobCvRelId);
-        // 校验记录的属性是否正确
-        JobCvRelDO jobCvRel = jobCvRelMapper.selectById(jobCvRelId);
-        assertPojoEquals(createReqVO, jobCvRel, "id");
-    }
-
-    @Test
-    public void testUpdateJobCvRel_success() {
-        // mock 数据
-        JobCvRelDO dbJobCvRel = randomPojo(JobCvRelDO.class);
-        jobCvRelMapper.insert(dbJobCvRel);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        JobCvRelSaveReqVO updateReqVO = randomPojo(JobCvRelSaveReqVO.class, o -> {
-            o.setId(dbJobCvRel.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        jobCvRelService.updateJobCvRel(updateReqVO);
-        // 校验是否更新正确
-        JobCvRelDO jobCvRel = jobCvRelMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, jobCvRel);
-    }
-
-    @Test
-    public void testUpdateJobCvRel_notExists() {
-        // 准备参数
-        JobCvRelSaveReqVO updateReqVO = randomPojo(JobCvRelSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> jobCvRelService.updateJobCvRel(updateReqVO), JOB_CV_REL_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteJobCvRel_success() {
-        // mock 数据
-        JobCvRelDO dbJobCvRel = randomPojo(JobCvRelDO.class);
-        jobCvRelMapper.insert(dbJobCvRel);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbJobCvRel.getId();
-
-        // 调用
-        jobCvRelService.deleteJobCvRel(id);
-        // 校验数据不存在了
-        assertNull(jobCvRelMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteJobCvRel_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> jobCvRelService.deleteJobCvRel(id), JOB_CV_REL_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetJobCvRelPage() {
-        // mock 数据
-        JobCvRelDO dbJobCvRel = randomPojo(JobCvRelDO.class, o -> { // 等会查询到
-            o.setEnterpriseId(null);
-            o.setJobId(null);
-            o.setPublishUserId(null);
-            o.setUserId(null);
-            o.setStatus(null);
-            o.setCreateTime(null);
-        });
-        jobCvRelMapper.insert(dbJobCvRel);
-        // 测试 enterpriseId 不匹配
-        jobCvRelMapper.insert(cloneIgnoreId(dbJobCvRel, o -> o.setEnterpriseId(null)));
-        // 测试 jobId 不匹配
-        jobCvRelMapper.insert(cloneIgnoreId(dbJobCvRel, o -> o.setJobId(null)));
-        // 测试 publishUserId 不匹配
-        jobCvRelMapper.insert(cloneIgnoreId(dbJobCvRel, o -> o.setPublishUserId(null)));
-        // 测试 userId 不匹配
-        jobCvRelMapper.insert(cloneIgnoreId(dbJobCvRel, o -> o.setUserId(null)));
-        // 测试 status 不匹配
-        jobCvRelMapper.insert(cloneIgnoreId(dbJobCvRel, o -> o.setStatus(null)));
-        // 测试 createTime 不匹配
-        jobCvRelMapper.insert(cloneIgnoreId(dbJobCvRel, o -> o.setCreateTime(null)));
-        // 准备参数
-        JobCvRelPageReqVO reqVO = new JobCvRelPageReqVO();
-        reqVO.setEnterpriseId(null);
-        reqVO.setJobId(null);
-        reqVO.setPublishUserId(null);
-        reqVO.setUserId(null);
-        reqVO.setStatus(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<JobCvRelDO> pageResult = jobCvRelService.getJobCvRelPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbJobCvRel, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/job/JobInterestedServiceImplTest.java

@@ -1,156 +0,0 @@
-package com.citu.module.menduner.system.service.job;
-
-import com.citu.module.menduner.system.controller.base.job.JobInterestedPageReqVO;
-import com.citu.module.menduner.system.controller.base.job.JobInterestedSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.job.JobInterestedDO;
-import com.citu.module.menduner.system.dal.mysql.job.JobInterestedMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_JOB_INTERESTED_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link JobInterestedServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(JobInterestedServiceImpl.class)
-public class JobInterestedServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private JobInterestedServiceImpl jobInterestedService;
-
-    @Resource
-    private JobInterestedMapper jobInterestedMapper;
-
-    @Test
-    public void testCreateJobInterested_success() {
-        // 准备参数
-        JobInterestedSaveReqVO createReqVO = randomPojo(JobInterestedSaveReqVO.class).setId(null);
-
-        // 调用
-        Long jobInterestedId = jobInterestedService.createJobInterested(createReqVO);
-        // 断言
-        assertNotNull(jobInterestedId);
-        // 校验记录的属性是否正确
-        JobInterestedDO jobInterested = jobInterestedMapper.selectById(jobInterestedId);
-        assertPojoEquals(createReqVO, jobInterested, "id");
-    }
-
-    @Test
-    public void testUpdateJobInterested_success() {
-        // mock 数据
-        JobInterestedDO dbJobInterested = randomPojo(JobInterestedDO.class);
-        jobInterestedMapper.insert(dbJobInterested);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        JobInterestedSaveReqVO updateReqVO = randomPojo(JobInterestedSaveReqVO.class, o -> {
-            o.setId(dbJobInterested.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        jobInterestedService.updateJobInterested(updateReqVO);
-        // 校验是否更新正确
-        JobInterestedDO jobInterested = jobInterestedMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, jobInterested);
-    }
-
-    @Test
-    public void testUpdateJobInterested_notExists() {
-        // 准备参数
-        JobInterestedSaveReqVO updateReqVO = randomPojo(JobInterestedSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> jobInterestedService.updateJobInterested(updateReqVO), MDE_JOB_INTERESTED_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteJobInterested_success() {
-        // mock 数据
-        JobInterestedDO dbJobInterested = randomPojo(JobInterestedDO.class);
-        jobInterestedMapper.insert(dbJobInterested);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbJobInterested.getId();
-
-        // 调用
-        jobInterestedService.deleteJobInterested(id);
-       // 校验数据不存在了
-       assertNull(jobInterestedMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteJobInterested_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> jobInterestedService.deleteJobInterested(id), MDE_JOB_INTERESTED_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetJobInterestedPage() {
-       // mock 数据
-       JobInterestedDO dbJobInterested = randomPojo(JobInterestedDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setJobType(null);
-           o.setPositionId(null);
-           o.setIndustryIdList(null);
-           o.setPayFrom(null);
-           o.setPayTo(null);
-           o.setWorkAreaId(null);
-           o.setInterestedAreaIdList(null);
-           o.setCreateTime(null);
-       });
-       jobInterestedMapper.insert(dbJobInterested);
-       // 测试 userId 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setUserId(null)));
-       // 测试 jobType 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setJobType(null)));
-       // 测试 positionId 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setPositionId(null)));
-       // 测试 industryIdList 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setIndustryIdList(null)));
-       // 测试 payFrom 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setPayFrom(null)));
-       // 测试 payTo 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setPayTo(null)));
-       // 测试 workAreaId 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setWorkAreaId(null)));
-       // 测试 interestedAreaIdList 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setInterestedAreaIdList(null)));
-       // 测试 createTime 不匹配
-       jobInterestedMapper.insert(cloneIgnoreId(dbJobInterested, o -> o.setCreateTime(null)));
-       // 准备参数
-       JobInterestedPageReqVO reqVO = new JobInterestedPageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setJobType(null);
-       reqVO.setPositionId(null);
-       reqVO.setIndustryIdList(null);
-       reqVO.setPayFrom(null);
-       reqVO.setPayTo(null);
-       reqVO.setWorkAreaId(null);
-       reqVO.setInterestedAreaIdList(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<JobInterestedDO> pageResult = jobInterestedService.getJobInterestedPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbJobInterested, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/major/MajorServiceImplTest.java

@@ -1,136 +0,0 @@
-package com.citu.module.menduner.system.service.major;
-
-import com.citu.module.menduner.system.controller.base.major.MajorPageReqVO;
-import com.citu.module.menduner.system.controller.base.major.MajorSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.major.MajorDO;
-import com.citu.module.menduner.system.dal.mysql.major.MajorMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_MAJOR_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link MajorServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(MajorServiceImpl.class)
-public class MajorServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private MajorServiceImpl majorService;
-
-    @Resource
-    private MajorMapper majorMapper;
-
-    @Test
-    public void testCreateMajor_success() {
-        // 准备参数
-        MajorSaveReqVO createReqVO = randomPojo(MajorSaveReqVO.class).setId(null);
-
-        // 调用
-        Long majorId = majorService.createMajor(createReqVO);
-        // 断言
-        assertNotNull(majorId);
-        // 校验记录的属性是否正确
-        MajorDO major = majorMapper.selectById(majorId);
-        assertPojoEquals(createReqVO, major, "id");
-    }
-
-    @Test
-    public void testUpdateMajor_success() {
-        // mock 数据
-        MajorDO dbMajor = randomPojo(MajorDO.class);
-        majorMapper.insert(dbMajor);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        MajorSaveReqVO updateReqVO = randomPojo(MajorSaveReqVO.class, o -> {
-            o.setId(dbMajor.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        majorService.updateMajor(updateReqVO);
-        // 校验是否更新正确
-        MajorDO major = majorMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, major);
-    }
-
-    @Test
-    public void testUpdateMajor_notExists() {
-        // 准备参数
-        MajorSaveReqVO updateReqVO = randomPojo(MajorSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> majorService.updateMajor(updateReqVO), MDE_MAJOR_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteMajor_success() {
-        // mock 数据
-        MajorDO dbMajor = randomPojo(MajorDO.class);
-        majorMapper.insert(dbMajor);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbMajor.getId();
-
-        // 调用
-        majorService.deleteMajor(id);
-       // 校验数据不存在了
-       assertNull(majorMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteMajor_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> majorService.deleteMajor(id), MDE_MAJOR_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetMajorPage() {
-       // mock 数据
-       MajorDO dbMajor = randomPojo(MajorDO.class, o -> { // 等会查询到
-           o.setNameCn(null);
-           o.setNameEn(null);
-           o.setStatus(null);
-           o.setCreateTime(null);
-       });
-       majorMapper.insert(dbMajor);
-       // 测试 nameCn 不匹配
-       majorMapper.insert(cloneIgnoreId(dbMajor, o -> o.setNameCn(null)));
-       // 测试 nameEn 不匹配
-       majorMapper.insert(cloneIgnoreId(dbMajor, o -> o.setNameEn(null)));
-       // 测试 status 不匹配
-       majorMapper.insert(cloneIgnoreId(dbMajor, o -> o.setStatus(null)));
-       // 测试 createTime 不匹配
-       majorMapper.insert(cloneIgnoreId(dbMajor, o -> o.setCreateTime(null)));
-       // 准备参数
-       MajorPageReqVO reqVO = new MajorPageReqVO();
-       reqVO.setNameCn(null);
-       reqVO.setNameEn(null);
-       reqVO.setStatus(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<MajorDO> pageResult = majorService.getMajorPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbMajor, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/person/PersonBrowseRecordServiceImplTest.java

@@ -1,208 +0,0 @@
-package com.citu.module.menduner.system.service.person;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.person.record.PersonBrowseRecordPageReqVO;
-import com.citu.module.menduner.system.controller.base.person.record.PersonBrowseRecordSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.person.PersonBrowseRecordDO;
-import com.citu.module.menduner.system.dal.mysql.person.PersonBrowseRecordMapper;
-import com.citu.module.menduner.system.service.person.record.PersonBrowseRecordServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.PERSON_BROWSE_RECORD_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PersonBrowseRecordServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PersonBrowseRecordServiceImpl.class)
-public class PersonBrowseRecordServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PersonBrowseRecordServiceImpl personBrowseRecordService;
-
-    @Resource
-    private PersonBrowseRecordMapper personBrowseRecordMapper;
-
-    @Test
-    public void testCreatePersonBrowseRecord_success() {
-        // 准备参数
-        PersonBrowseRecordSaveReqVO createReqVO = randomPojo(PersonBrowseRecordSaveReqVO.class).setId(null);
-
-        // 调用
-        Long personBrowseRecordId = personBrowseRecordService.createPersonBrowseRecord(createReqVO);
-        // 断言
-        assertNotNull(personBrowseRecordId);
-        // 校验记录的属性是否正确
-        PersonBrowseRecordDO personBrowseRecord = personBrowseRecordMapper.selectById(personBrowseRecordId);
-        assertPojoEquals(createReqVO, personBrowseRecord, "id");
-    }
-
-    @Test
-    public void testUpdatePersonBrowseRecord_success() {
-        // mock 数据
-        PersonBrowseRecordDO dbPersonBrowseRecord = randomPojo(PersonBrowseRecordDO.class);
-        personBrowseRecordMapper.insert(dbPersonBrowseRecord);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PersonBrowseRecordSaveReqVO updateReqVO = randomPojo(PersonBrowseRecordSaveReqVO.class, o -> {
-            o.setId(dbPersonBrowseRecord.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        personBrowseRecordService.updatePersonBrowseRecord(updateReqVO);
-        // 校验是否更新正确
-        PersonBrowseRecordDO personBrowseRecord = personBrowseRecordMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, personBrowseRecord);
-    }
-
-    @Test
-    public void testUpdatePersonBrowseRecord_notExists() {
-        // 准备参数
-        PersonBrowseRecordSaveReqVO updateReqVO = randomPojo(PersonBrowseRecordSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> personBrowseRecordService.updatePersonBrowseRecord(updateReqVO), PERSON_BROWSE_RECORD_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeletePersonBrowseRecord_success() {
-        // mock 数据
-        PersonBrowseRecordDO dbPersonBrowseRecord = randomPojo(PersonBrowseRecordDO.class);
-        personBrowseRecordMapper.insert(dbPersonBrowseRecord);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbPersonBrowseRecord.getId();
-
-        // 调用
-        personBrowseRecordService.deletePersonBrowseRecord(id);
-        // 校验数据不存在了
-        assertNull(personBrowseRecordMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeletePersonBrowseRecord_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> personBrowseRecordService.deletePersonBrowseRecord(id), PERSON_BROWSE_RECORD_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetPersonBrowseRecordPage() {
-        // mock 数据
-        PersonBrowseRecordDO dbPersonBrowseRecord = randomPojo(PersonBrowseRecordDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setJobId(null);
-            o.setAreaId(null);
-            o.setPositionId(null);
-            o.setEnterpriseId(null);
-            o.setAreaName(null);
-            o.setJobName(null);
-            o.setType(null);
-            o.setExpType(null);
-            o.setEduType(null);
-            o.setPayFrom(null);
-            o.setPayTo(null);
-            o.setPayUnit(null);
-            o.setCurrencyType(null);
-            o.setContactUserId(null);
-            o.setContactUserName(null);
-            o.setContactUserPostName(null);
-            o.setEnterpriseName(null);
-            o.setIndustryId(null);
-            o.setFinancingStatus(null);
-            o.setScale(null);
-            o.setCreateTime(null);
-        });
-        personBrowseRecordMapper.insert(dbPersonBrowseRecord);
-        // 测试 userId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setUserId(null)));
-        // 测试 jobId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setJobId(null)));
-        // 测试 areaId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setAreaId(null)));
-        // 测试 positionId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setPositionId(null)));
-        // 测试 enterpriseId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setEnterpriseId(null)));
-        // 测试 areaName 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setAreaName(null)));
-        // 测试 jobName 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setJobName(null)));
-        // 测试 type 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setType(null)));
-        // 测试 expType 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setExpType(null)));
-        // 测试 eduType 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setEduType(null)));
-        // 测试 payFrom 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setPayFrom(null)));
-        // 测试 payTo 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setPayTo(null)));
-        // 测试 payUnit 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setPayUnit(null)));
-        // 测试 currencyType 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setCurrencyType(null)));
-        // 测试 contactUserId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setContactUserId(null)));
-        // 测试 contactUserName 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setContactUserName(null)));
-        // 测试 contactUserPostName 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setContactUserPostName(null)));
-        // 测试 enterpriseName 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setEnterpriseName(null)));
-        // 测试 industryId 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setIndustryId(null)));
-        // 测试 financingStatus 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setFinancingStatus(null)));
-        // 测试 scale 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setScale(null)));
-        // 测试 createTime 不匹配
-        personBrowseRecordMapper.insert(cloneIgnoreId(dbPersonBrowseRecord, o -> o.setCreateTime(null)));
-        // 准备参数
-        PersonBrowseRecordPageReqVO reqVO = new PersonBrowseRecordPageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setJobId(null);
-        reqVO.setAreaId(null);
-        reqVO.setPositionId(null);
-        reqVO.setEnterpriseId(null);
-        reqVO.setAreaName(null);
-        reqVO.setJobName(null);
-        reqVO.setType(null);
-        reqVO.setExpType(null);
-        reqVO.setEduType(null);
-        reqVO.setPayFrom(null);
-        reqVO.setPayTo(null);
-        reqVO.setPayUnit(null);
-        reqVO.setCurrencyType(null);
-        reqVO.setContactUserId(null);
-        reqVO.setContactUserName(null);
-        reqVO.setContactUserPostName(null);
-        reqVO.setEnterpriseName(null);
-        reqVO.setIndustryId(null);
-        reqVO.setFinancingStatus(null);
-        reqVO.setScale(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<PersonBrowseRecordDO> pageResult = personBrowseRecordService.getPersonBrowseRecordPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbPersonBrowseRecord, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/person/PersonCertificateServiceImplTest.java

@@ -1,133 +0,0 @@
-package com.citu.module.menduner.system.service.person;
-
-import com.citu.module.menduner.system.controller.base.person.certificate.PersonCertificatePageReqVO;
-import com.citu.module.menduner.system.controller.base.person.certificate.PersonCertificateSaveReqVO;
-import com.citu.module.menduner.system.service.person.certificate.PersonCertificateServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.person.PersonCertificateDO;
-import com.citu.module.menduner.system.dal.mysql.person.PersonCertificateMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_USER_CERTIFICATE_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PersonCertificateServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PersonCertificateServiceImpl.class)
-public class PersonCertificateServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PersonCertificateServiceImpl userCertificateService;
-
-    @Resource
-    private PersonCertificateMapper personCertificateMapper;
-
-    @Test
-    public void testCreateUserCertificate_success() {
-        // 准备参数
-        PersonCertificateSaveReqVO createReqVO = randomPojo(PersonCertificateSaveReqVO.class).setId(null);
-
-        // 调用
-        Long userCertificateId = userCertificateService.createUserCertificate(createReqVO);
-        // 断言
-        assertNotNull(userCertificateId);
-        // 校验记录的属性是否正确
-        PersonCertificateDO userCertificate = personCertificateMapper.selectById(userCertificateId);
-        assertPojoEquals(createReqVO, userCertificate, "id");
-    }
-
-    @Test
-    public void testUpdateUserCertificate_success() {
-        // mock 数据
-        PersonCertificateDO dbUserCertificate = randomPojo(PersonCertificateDO.class);
-        personCertificateMapper.insert(dbUserCertificate);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PersonCertificateSaveReqVO updateReqVO = randomPojo(PersonCertificateSaveReqVO.class, o -> {
-            o.setId(dbUserCertificate.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        userCertificateService.updateUserCertificate(updateReqVO);
-        // 校验是否更新正确
-        PersonCertificateDO userCertificate = personCertificateMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, userCertificate);
-    }
-
-    @Test
-    public void testUpdateUserCertificate_notExists() {
-        // 准备参数
-        PersonCertificateSaveReqVO updateReqVO = randomPojo(PersonCertificateSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userCertificateService.updateUserCertificate(updateReqVO), MDE_USER_CERTIFICATE_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteUserCertificate_success() {
-        // mock 数据
-        PersonCertificateDO dbUserCertificate = randomPojo(PersonCertificateDO.class);
-        personCertificateMapper.insert(dbUserCertificate);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbUserCertificate.getId();
-
-        // 调用
-        userCertificateService.deleteUserCertificate(id);
-       // 校验数据不存在了
-       assertNull(personCertificateMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteUserCertificate_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userCertificateService.deleteUserCertificate(id), MDE_USER_CERTIFICATE_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetUserCertificatePage() {
-       // mock 数据
-       PersonCertificateDO dbUserCertificate = randomPojo(PersonCertificateDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setCertificateId(null);
-           o.setCreateTime(null);
-       });
-       personCertificateMapper.insert(dbUserCertificate);
-       // 测试 userId 不匹配
-       personCertificateMapper.insert(cloneIgnoreId(dbUserCertificate, o -> o.setUserId(null)));
-       // 测试 certificateId 不匹配
-       personCertificateMapper.insert(cloneIgnoreId(dbUserCertificate, o -> o.setCertificateId(null)));
-       // 测试 createTime 不匹配
-       personCertificateMapper.insert(cloneIgnoreId(dbUserCertificate, o -> o.setCreateTime(null)));
-       // 准备参数
-       PersonCertificatePageReqVO reqVO = new PersonCertificatePageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setCertificateId(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<PersonCertificateDO> pageResult = userCertificateService.getUserCertificatePage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbUserCertificate, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/person/PersonEnterpriseSubscribeServiceImplTest.java

@@ -1,132 +0,0 @@
-package com.citu.module.menduner.system.service.person;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.person.subscribe.PersonEnterpriseSubscribePageReqVO;
-import com.citu.module.menduner.system.controller.base.person.subscribe.PersonEnterpriseSubscribeSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.person.PersonEnterpriseSubscribeDO;
-import com.citu.module.menduner.system.dal.mysql.person.PersonEnterpriseSubscribeMapper;
-import com.citu.module.menduner.system.service.person.subscribe.PersonEnterpriseSubscribeServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.PERSON_ENTERPRISE_ATTENTION_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PersonEnterpriseSubscribeServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PersonEnterpriseSubscribeServiceImpl.class)
-public class PersonEnterpriseSubscribeServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PersonEnterpriseSubscribeServiceImpl personEnterpriseSubscribeService;
-
-    @Resource
-    private PersonEnterpriseSubscribeMapper personEnterpriseSubscribeMapper;
-
-    @Test
-    public void testCreatePersonEnterpriseSubscribe_success() {
-        // 准备参数
-        PersonEnterpriseSubscribeSaveReqVO createReqVO = randomPojo(PersonEnterpriseSubscribeSaveReqVO.class).setId(null);
-
-        // 调用
-        Long personEnterpriseSubscribeId = personEnterpriseSubscribeService.createPersonEnterpriseSubscribe(createReqVO);
-        // 断言
-        assertNotNull(personEnterpriseSubscribeId);
-        // 校验记录的属性是否正确
-        PersonEnterpriseSubscribeDO personEnterpriseSubscribe = personEnterpriseSubscribeMapper.selectById(personEnterpriseSubscribeId);
-        assertPojoEquals(createReqVO, personEnterpriseSubscribe, "id");
-    }
-
-    @Test
-    public void testUpdatePersonEnterpriseSubscribe_success() {
-        // mock 数据
-        PersonEnterpriseSubscribeDO dbPersonEnterpriseSubscribe = randomPojo(PersonEnterpriseSubscribeDO.class);
-        personEnterpriseSubscribeMapper.insert(dbPersonEnterpriseSubscribe);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PersonEnterpriseSubscribeSaveReqVO updateReqVO = randomPojo(PersonEnterpriseSubscribeSaveReqVO.class, o -> {
-            o.setId(dbPersonEnterpriseSubscribe.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        personEnterpriseSubscribeService.updatePersonEnterpriseSubscribe(updateReqVO);
-        // 校验是否更新正确
-        PersonEnterpriseSubscribeDO personEnterpriseSubscribe = personEnterpriseSubscribeMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, personEnterpriseSubscribe);
-    }
-
-    @Test
-    public void testUpdatePersonEnterpriseSubscribe_notExists() {
-        // 准备参数
-        PersonEnterpriseSubscribeSaveReqVO updateReqVO = randomPojo(PersonEnterpriseSubscribeSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> personEnterpriseSubscribeService.updatePersonEnterpriseSubscribe(updateReqVO), PERSON_ENTERPRISE_ATTENTION_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeletePersonEnterpriseSubscribe_success() {
-        // mock 数据
-        PersonEnterpriseSubscribeDO dbPersonEnterpriseSubscribe = randomPojo(PersonEnterpriseSubscribeDO.class);
-        personEnterpriseSubscribeMapper.insert(dbPersonEnterpriseSubscribe);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbPersonEnterpriseSubscribe.getId();
-
-        // 调用
-        personEnterpriseSubscribeService.deletePersonEnterpriseSubscribe(id);
-        // 校验数据不存在了
-        assertNull(personEnterpriseSubscribeMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeletePersonEnterpriseSubscribe_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> personEnterpriseSubscribeService.deletePersonEnterpriseSubscribe(id), PERSON_ENTERPRISE_ATTENTION_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetPersonEnterpriseSubscribePage() {
-        // mock 数据
-        PersonEnterpriseSubscribeDO dbPersonEnterpriseSubscribe = randomPojo(PersonEnterpriseSubscribeDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setEnterpriseId(null);
-            o.setCreateTime(null);
-        });
-        personEnterpriseSubscribeMapper.insert(dbPersonEnterpriseSubscribe);
-        // 测试 userId 不匹配
-        personEnterpriseSubscribeMapper.insert(cloneIgnoreId(dbPersonEnterpriseSubscribe, o -> o.setUserId(null)));
-        // 测试 enterpriseId 不匹配
-        personEnterpriseSubscribeMapper.insert(cloneIgnoreId(dbPersonEnterpriseSubscribe, o -> o.setEnterpriseId(null)));
-        // 测试 createTime 不匹配
-        personEnterpriseSubscribeMapper.insert(cloneIgnoreId(dbPersonEnterpriseSubscribe, o -> o.setCreateTime(null)));
-        // 准备参数
-        PersonEnterpriseSubscribePageReqVO reqVO = new PersonEnterpriseSubscribePageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setEnterpriseId(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<PersonEnterpriseSubscribeDO> pageResult = personEnterpriseSubscribeService.getPersonEnterpriseSubscribePage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbPersonEnterpriseSubscribe, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/person/PersonInfoServiceImplTest.java

@@ -1,173 +0,0 @@
-package com.citu.module.menduner.system.service.person;
-
-import com.citu.module.menduner.system.controller.base.person.info.PersonInfoPageReqVO;
-import com.citu.module.menduner.system.controller.base.person.info.PersonInfoSaveReqVO;
-import com.citu.module.menduner.system.service.person.info.PersonInfoServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.person.PersonInfoDO;
-import com.citu.module.menduner.system.dal.mysql.person.PersonInfoMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.*;
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PersonInfoServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PersonInfoServiceImpl.class)
-public class PersonInfoServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PersonInfoServiceImpl userInfoService;
-
-    @Resource
-    private PersonInfoMapper personInfoMapper;
-
-    @Test
-    public void testCreateUserInfo_success() {
-        // 准备参数
-        PersonInfoSaveReqVO createReqVO = randomPojo(PersonInfoSaveReqVO.class).setId(null);
-
-        // 调用
-        Long userInfoId = userInfoService.createUserInfo(createReqVO);
-        // 断言
-        assertNotNull(userInfoId);
-        // 校验记录的属性是否正确
-        PersonInfoDO userInfo = personInfoMapper.selectById(userInfoId);
-        assertPojoEquals(createReqVO, userInfo, "id");
-    }
-
-    @Test
-    public void testUpdateUserInfo_success() {
-        // mock 数据
-        PersonInfoDO dbUserInfo = randomPojo(PersonInfoDO.class);
-        personInfoMapper.insert(dbUserInfo);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PersonInfoSaveReqVO updateReqVO = randomPojo(PersonInfoSaveReqVO.class, o -> {
-            o.setId(dbUserInfo.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        userInfoService.updateUserInfo(updateReqVO);
-        // 校验是否更新正确
-        PersonInfoDO userInfo = personInfoMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, userInfo);
-    }
-
-    @Test
-    public void testUpdateUserInfo_notExists() {
-        // 准备参数
-        PersonInfoSaveReqVO updateReqVO = randomPojo(PersonInfoSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userInfoService.updateUserInfo(updateReqVO), MDE_USER_INFO_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteUserInfo_success() {
-        // mock 数据
-        PersonInfoDO dbUserInfo = randomPojo(PersonInfoDO.class);
-        personInfoMapper.insert(dbUserInfo);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbUserInfo.getId();
-
-        // 调用
-        userInfoService.deleteUserInfo(id);
-       // 校验数据不存在了
-       assertNull(personInfoMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteUserInfo_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userInfoService.deleteUserInfo(id), MDE_USER_INFO_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetUserInfoPage() {
-       // mock 数据
-       PersonInfoDO dbUserInfo = randomPojo(PersonInfoDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setName(null);
-           o.setSex(null);
-           o.setAvatar(null);
-           o.setPhone(null);
-           o.setEmail(null);
-           o.setWxCode(null);
-           o.setBirthday(null);
-           o.setMaritalStatus(null);
-           o.setAreaId(null);
-           o.setJobType(null);
-           o.setJobStatus(null);
-           o.setCreateTime(null);
-       });
-       personInfoMapper.insert(dbUserInfo);
-       // 测试 userId 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setUserId(null)));
-       // 测试 name 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setName(null)));
-       // 测试 sex 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setSex(null)));
-       // 测试 avatar 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setAvatar(null)));
-       // 测试 phone 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setPhone(null)));
-       // 测试 email 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setEmail(null)));
-       // 测试 wxCode 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setWxCode(null)));
-       // 测试 birthday 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setBirthday(null)));
-       // 测试 maritalStatus 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setMaritalStatus(null)));
-       // 测试 areaId 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setAreaId(null)));
-       // 测试 jobType 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setJobType(null)));
-       // 测试 jobStatus 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setJobStatus(null)));
-       // 测试 createTime 不匹配
-       personInfoMapper.insert(cloneIgnoreId(dbUserInfo, o -> o.setCreateTime(null)));
-       // 准备参数
-       PersonInfoPageReqVO reqVO = new PersonInfoPageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setName(null);
-       reqVO.setSex(null);
-       reqVO.setAvatar(null);
-       reqVO.setPhone(null);
-       reqVO.setEmail(null);
-       reqVO.setWxCode(null);
-       reqVO.setBirthday(null);
-       reqVO.setMaritalStatus(null);
-       reqVO.setAreaId(null);
-       reqVO.setJobType(null);
-       reqVO.setJobStatus(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<PersonInfoDO> pageResult = userInfoService.getUserInfoPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbUserInfo, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/person/PersonJobFavoriteServiceImplTest.java

@@ -1,132 +0,0 @@
-package com.citu.module.menduner.system.service.person;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.person.favorite.PersonJobFavoritePageReqVO;
-import com.citu.module.menduner.system.controller.base.person.favorite.PersonJobFavoriteSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.person.PersonJobFavoriteDO;
-import com.citu.module.menduner.system.dal.mysql.person.PersonJobFavoriteMapper;
-import com.citu.module.menduner.system.service.person.favorite.PersonJobFavoriteServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.PERSON_JOB_COLLECTION_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PersonJobFavoriteServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PersonJobFavoriteServiceImpl.class)
-public class PersonJobFavoriteServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PersonJobFavoriteServiceImpl personJobFavoriteService;
-
-    @Resource
-    private PersonJobFavoriteMapper personJobFavoriteMapper;
-
-    @Test
-    public void testCreatePersonJobFavorite_success() {
-        // 准备参数
-        PersonJobFavoriteSaveReqVO createReqVO = randomPojo(PersonJobFavoriteSaveReqVO.class).setId(null);
-
-        // 调用
-        Long personJobFavoriteId = personJobFavoriteService.createPersonJobFavorite(createReqVO);
-        // 断言
-        assertNotNull(personJobFavoriteId);
-        // 校验记录的属性是否正确
-        PersonJobFavoriteDO personJobFavorite = personJobFavoriteMapper.selectById(personJobFavoriteId);
-        assertPojoEquals(createReqVO, personJobFavorite, "id");
-    }
-
-    @Test
-    public void testUpdatePersonJobFavorite_success() {
-        // mock 数据
-        PersonJobFavoriteDO dbPersonJobFavorite = randomPojo(PersonJobFavoriteDO.class);
-        personJobFavoriteMapper.insert(dbPersonJobFavorite);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PersonJobFavoriteSaveReqVO updateReqVO = randomPojo(PersonJobFavoriteSaveReqVO.class, o -> {
-            o.setId(dbPersonJobFavorite.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        personJobFavoriteService.updatePersonJobFavorite(updateReqVO);
-        // 校验是否更新正确
-        PersonJobFavoriteDO personJobFavorite = personJobFavoriteMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, personJobFavorite);
-    }
-
-    @Test
-    public void testUpdatePersonJobFavorite_notExists() {
-        // 准备参数
-        PersonJobFavoriteSaveReqVO updateReqVO = randomPojo(PersonJobFavoriteSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> personJobFavoriteService.updatePersonJobFavorite(updateReqVO), PERSON_JOB_COLLECTION_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeletePersonJobFavorite_success() {
-        // mock 数据
-        PersonJobFavoriteDO dbPersonJobFavorite = randomPojo(PersonJobFavoriteDO.class);
-        personJobFavoriteMapper.insert(dbPersonJobFavorite);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbPersonJobFavorite.getId();
-
-        // 调用
-        personJobFavoriteService.deletePersonJobFavorite(id);
-        // 校验数据不存在了
-        assertNull(personJobFavoriteMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeletePersonJobFavorite_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> personJobFavoriteService.deletePersonJobFavorite(id), PERSON_JOB_COLLECTION_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetPersonJobFavoritePage() {
-        // mock 数据
-        PersonJobFavoriteDO dbPersonJobFavorite = randomPojo(PersonJobFavoriteDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setJobId(null);
-            o.setCreateTime(null);
-        });
-        personJobFavoriteMapper.insert(dbPersonJobFavorite);
-        // 测试 userId 不匹配
-        personJobFavoriteMapper.insert(cloneIgnoreId(dbPersonJobFavorite, o -> o.setUserId(null)));
-        // 测试 jobId 不匹配
-        personJobFavoriteMapper.insert(cloneIgnoreId(dbPersonJobFavorite, o -> o.setJobId(null)));
-        // 测试 createTime 不匹配
-        personJobFavoriteMapper.insert(cloneIgnoreId(dbPersonJobFavorite, o -> o.setCreateTime(null)));
-        // 准备参数
-        PersonJobFavoritePageReqVO reqVO = new PersonJobFavoritePageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setJobId(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<PersonJobFavoriteDO> pageResult = personJobFavoriteService.getPersonJobFavoritePage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbPersonJobFavorite, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/person/PersonSkillServiceImplTest.java

@@ -1,137 +0,0 @@
-package com.citu.module.menduner.system.service.person;
-
-import com.citu.module.menduner.system.controller.base.person.skill.PersonSkillPageReqVO;
-import com.citu.module.menduner.system.controller.base.person.skill.PersonSkillSaveReqVO;
-import com.citu.module.menduner.system.service.person.skill.PersonSkillServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.person.PersonSkillDO;
-import com.citu.module.menduner.system.dal.mysql.person.PersonSkillMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_USER_SKILL_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PersonSkillServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PersonSkillServiceImpl.class)
-public class PersonSkillServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PersonSkillServiceImpl userSkillService;
-
-    @Resource
-    private PersonSkillMapper personSkillMapper;
-
-    @Test
-    public void testCreateUserSkill_success() {
-        // 准备参数
-        PersonSkillSaveReqVO createReqVO = randomPojo(PersonSkillSaveReqVO.class).setId(null);
-
-        // 调用
-        Long userSkillId = userSkillService.createUserSkill(createReqVO);
-        // 断言
-        assertNotNull(userSkillId);
-        // 校验记录的属性是否正确
-        PersonSkillDO userSkill = personSkillMapper.selectById(userSkillId);
-        assertPojoEquals(createReqVO, userSkill, "id");
-    }
-
-    @Test
-    public void testUpdateUserSkill_success() {
-        // mock 数据
-        PersonSkillDO dbUserSkill = randomPojo(PersonSkillDO.class);
-        personSkillMapper.insert(dbUserSkill);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PersonSkillSaveReqVO updateReqVO = randomPojo(PersonSkillSaveReqVO.class, o -> {
-            o.setId(dbUserSkill.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        userSkillService.updateUserSkill(updateReqVO);
-        // 校验是否更新正确
-        PersonSkillDO userSkill = personSkillMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, userSkill);
-    }
-
-    @Test
-    public void testUpdateUserSkill_notExists() {
-        // 准备参数
-        PersonSkillSaveReqVO updateReqVO = randomPojo(PersonSkillSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userSkillService.updateUserSkill(updateReqVO), MDE_USER_SKILL_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteUserSkill_success() {
-        // mock 数据
-        PersonSkillDO dbUserSkill = randomPojo(PersonSkillDO.class);
-        personSkillMapper.insert(dbUserSkill);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbUserSkill.getId();
-
-        // 调用
-        userSkillService.deleteUserSkill(id);
-       // 校验数据不存在了
-       assertNull(personSkillMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteUserSkill_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userSkillService.deleteUserSkill(id), MDE_USER_SKILL_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetUserSkillPage() {
-       // mock 数据
-       PersonSkillDO dbUserSkill = randomPojo(PersonSkillDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setSkillId(null);
-           o.setLevel(null);
-           o.setCreateTime(null);
-       });
-       personSkillMapper.insert(dbUserSkill);
-       // 测试 userId 不匹配
-       personSkillMapper.insert(cloneIgnoreId(dbUserSkill, o -> o.setUserId(null)));
-       // 测试 name 不匹配
-       personSkillMapper.insert(cloneIgnoreId(dbUserSkill, o -> o.setSkillId(null)));
-       // 测试 level 不匹配
-       personSkillMapper.insert(cloneIgnoreId(dbUserSkill, o -> o.setLevel(null)));
-       // 测试 createTime 不匹配
-       personSkillMapper.insert(cloneIgnoreId(dbUserSkill, o -> o.setCreateTime(null)));
-       // 准备参数
-       PersonSkillPageReqVO reqVO = new PersonSkillPageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setSkillId(null);
-       reqVO.setLevel(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<PersonSkillDO> pageResult = userSkillService.getUserSkillPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbUserSkill, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/position/PositionServiceImplTest.java

@@ -1,140 +0,0 @@
-package com.citu.module.menduner.system.service.position;
-
-import com.citu.module.menduner.system.controller.base.position.PositionPageReqVO;
-import com.citu.module.menduner.system.controller.base.position.PositionSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.position.PositionDO;
-import com.citu.module.menduner.system.dal.mysql.position.PositionMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.*;
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PositionServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PositionServiceImpl.class)
-public class PositionServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PositionServiceImpl positionService;
-
-    @Resource
-    private PositionMapper positionMapper;
-
-    @Test
-    public void testCreatePosition_success() {
-        // 准备参数
-        PositionSaveReqVO createReqVO = randomPojo(PositionSaveReqVO.class).setId(null);
-
-        // 调用
-        Long positionId = positionService.createPosition(createReqVO);
-        // 断言
-        assertNotNull(positionId);
-        // 校验记录的属性是否正确
-        PositionDO position = positionMapper.selectById(positionId);
-        assertPojoEquals(createReqVO, position, "id");
-    }
-
-    @Test
-    public void testUpdatePosition_success() {
-        // mock 数据
-        PositionDO dbPosition = randomPojo(PositionDO.class);
-        positionMapper.insert(dbPosition);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PositionSaveReqVO updateReqVO = randomPojo(PositionSaveReqVO.class, o -> {
-            o.setId(dbPosition.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        positionService.updatePosition(updateReqVO);
-        // 校验是否更新正确
-        PositionDO position = positionMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, position);
-    }
-
-    @Test
-    public void testUpdatePosition_notExists() {
-        // 准备参数
-        PositionSaveReqVO updateReqVO = randomPojo(PositionSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> positionService.updatePosition(updateReqVO), MDE_POSITION_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeletePosition_success() {
-        // mock 数据
-        PositionDO dbPosition = randomPojo(PositionDO.class);
-        positionMapper.insert(dbPosition);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbPosition.getId();
-
-        // 调用
-        positionService.deletePosition(id);
-        // 校验数据不存在了
-        assertNull(positionMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeletePosition_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> positionService.deletePosition(id), MDE_POSITION_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetPositionPage() {
-        // mock 数据
-        PositionDO dbPosition = randomPojo(PositionDO.class, o -> { // 等会查询到
-            o.setNameCn(null);
-            o.setNameEn(null);
-            o.setParentId(null);
-            o.setLevel(null);
-            o.setCreateTime(null);
-        });
-        positionMapper.insert(dbPosition);
-        // 测试 nameCn 不匹配
-        positionMapper.insert(cloneIgnoreId(dbPosition, o -> o.setNameCn(null)));
-        // 测试 nameEn 不匹配
-        positionMapper.insert(cloneIgnoreId(dbPosition, o -> o.setNameEn(null)));
-        // 测试 parentId 不匹配
-        positionMapper.insert(cloneIgnoreId(dbPosition, o -> o.setParentId(null)));
-        // 测试 level 不匹配
-        positionMapper.insert(cloneIgnoreId(dbPosition, o -> o.setLevel(null)));
-        // 测试 createTime 不匹配
-        positionMapper.insert(cloneIgnoreId(dbPosition, o -> o.setCreateTime(null)));
-        // 准备参数
-        PositionPageReqVO reqVO = new PositionPageReqVO();
-        reqVO.setNameCn(null);
-        reqVO.setNameEn(null);
-        reqVO.setParentId(null);
-        reqVO.setLevel(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<PositionDO> pageResult = positionService.getPositionPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbPosition, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/positiontag/PositionTagServiceImplTest.java

@@ -1,133 +0,0 @@
-package com.citu.module.menduner.system.service.positiontag;
-
-import com.citu.module.menduner.system.controller.base.position.PositionTagPageReqVO;
-import com.citu.module.menduner.system.controller.base.position.PositionTagSaveReqVO;
-import com.citu.module.menduner.system.service.position.PositionTagServiceImpl;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.position.PositionTagDO;
-import com.citu.module.menduner.system.dal.mysql.position.PositionTagMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_POSITION_TAG_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link PositionTagServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(PositionTagServiceImpl.class)
-public class PositionTagServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private PositionTagServiceImpl positionTagService;
-
-    @Resource
-    private PositionTagMapper positionTagMapper;
-
-    @Test
-    public void testCreatePositionTag_success() {
-        // 准备参数
-        PositionTagSaveReqVO createReqVO = randomPojo(PositionTagSaveReqVO.class).setId(null);
-
-        // 调用
-        Long positionTagId = positionTagService.createPositionTag(createReqVO);
-        // 断言
-        assertNotNull(positionTagId);
-        // 校验记录的属性是否正确
-        PositionTagDO positionTag = positionTagMapper.selectById(positionTagId);
-        assertPojoEquals(createReqVO, positionTag, "id");
-    }
-
-    @Test
-    public void testUpdatePositionTag_success() {
-        // mock 数据
-        PositionTagDO dbPositionTag = randomPojo(PositionTagDO.class);
-        positionTagMapper.insert(dbPositionTag);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        PositionTagSaveReqVO updateReqVO = randomPojo(PositionTagSaveReqVO.class, o -> {
-            o.setId(dbPositionTag.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        positionTagService.updatePositionTag(updateReqVO);
-        // 校验是否更新正确
-        PositionTagDO positionTag = positionTagMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, positionTag);
-    }
-
-    @Test
-    public void testUpdatePositionTag_notExists() {
-        // 准备参数
-        PositionTagSaveReqVO updateReqVO = randomPojo(PositionTagSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> positionTagService.updatePositionTag(updateReqVO), MDE_POSITION_TAG_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeletePositionTag_success() {
-        // mock 数据
-        PositionTagDO dbPositionTag = randomPojo(PositionTagDO.class);
-        positionTagMapper.insert(dbPositionTag);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbPositionTag.getId();
-
-        // 调用
-        positionTagService.deletePositionTag(id);
-       // 校验数据不存在了
-       assertNull(positionTagMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeletePositionTag_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> positionTagService.deletePositionTag(id), MDE_POSITION_TAG_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetPositionTagPage() {
-       // mock 数据
-       PositionTagDO dbPositionTag = randomPojo(PositionTagDO.class, o -> { // 等会查询到
-           o.setPositionId(null);
-           o.setLabel(null);
-           o.setCreateTime(null);
-       });
-       positionTagMapper.insert(dbPositionTag);
-       // 测试 positionId 不匹配
-       positionTagMapper.insert(cloneIgnoreId(dbPositionTag, o -> o.setPositionId(null)));
-       // 测试 label 不匹配
-       positionTagMapper.insert(cloneIgnoreId(dbPositionTag, o -> o.setLabel(null)));
-       // 测试 createTime 不匹配
-       positionTagMapper.insert(cloneIgnoreId(dbPositionTag, o -> o.setCreateTime(null)));
-       // 准备参数
-       PositionTagPageReqVO reqVO = new PositionTagPageReqVO();
-       reqVO.setPositionId(null);
-       reqVO.setLabel(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<PositionTagDO> pageResult = positionTagService.getPositionTagPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbPositionTag, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/projectexp/ProjectExpServiceImplTest.java

@@ -1,145 +0,0 @@
-package com.citu.module.menduner.system.service.projectexp;
-
-import com.citu.module.menduner.system.controller.base.projectexp.ProjectExpPageReqVO;
-import com.citu.module.menduner.system.controller.base.projectexp.ProjectExpSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.projectexp.ProjectExpDO;
-import com.citu.module.menduner.system.dal.mysql.projectexp.ProjectExpMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import java.time.LocalDate;
-
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.*;
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link ProjectExpServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(ProjectExpServiceImpl.class)
-public class ProjectExpServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private ProjectExpServiceImpl projectExpService;
-
-    @Resource
-    private ProjectExpMapper projectExpMapper;
-
-    @Test
-    public void testCreateProjectExp_success() {
-        // 准备参数
-        ProjectExpSaveReqVO createReqVO = randomPojo(ProjectExpSaveReqVO.class).setId(null);
-
-        // 调用
-        Long projectExpId = projectExpService.createProjectExp(createReqVO);
-        // 断言
-        assertNotNull(projectExpId);
-        // 校验记录的属性是否正确
-        ProjectExpDO projectExp = projectExpMapper.selectById(projectExpId);
-        assertPojoEquals(createReqVO, projectExp, "id");
-    }
-
-    @Test
-    public void testUpdateProjectExp_success() {
-        // mock 数据
-        ProjectExpDO dbProjectExp = randomPojo(ProjectExpDO.class);
-        projectExpMapper.insert(dbProjectExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        ProjectExpSaveReqVO updateReqVO = randomPojo(ProjectExpSaveReqVO.class, o -> {
-            o.setId(dbProjectExp.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        projectExpService.updateProjectExp(updateReqVO);
-        // 校验是否更新正确
-        ProjectExpDO projectExp = projectExpMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, projectExp);
-    }
-
-    @Test
-    public void testUpdateProjectExp_notExists() {
-        // 准备参数
-        ProjectExpSaveReqVO updateReqVO = randomPojo(ProjectExpSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> projectExpService.updateProjectExp(updateReqVO), PROJECT_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteProjectExp_success() {
-        // mock 数据
-        ProjectExpDO dbProjectExp = randomPojo(ProjectExpDO.class);
-        projectExpMapper.insert(dbProjectExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbProjectExp.getId();
-
-        // 调用
-        projectExpService.deleteProjectExp(id);
-        // 校验数据不存在了
-        assertNull(projectExpMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteProjectExp_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> projectExpService.deleteProjectExp(id), PROJECT_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetProjectExpPage() {
-        // mock 数据
-        ProjectExpDO dbProjectExp = randomPojo(ProjectExpDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setName(null);
-            o.setStartTime(null);
-            o.setEndTime(null);
-            o.setCreateTime(null);
-        });
-        projectExpMapper.insert(dbProjectExp);
-        // 测试 userId 不匹配
-        projectExpMapper.insert(cloneIgnoreId(dbProjectExp, o -> o.setUserId(null)));
-        // 测试 name 不匹配
-        projectExpMapper.insert(cloneIgnoreId(dbProjectExp, o -> o.setName(null)));
-        // 测试 startTime 不匹配
-        projectExpMapper.insert(cloneIgnoreId(dbProjectExp, o -> o.setStartTime(null)));
-        // 测试 endTime 不匹配
-        projectExpMapper.insert(cloneIgnoreId(dbProjectExp, o -> o.setEndTime(null)));
-        // 测试 createTime 不匹配
-        projectExpMapper.insert(cloneIgnoreId(dbProjectExp, o -> o.setCreateTime(null)));
-        // 准备参数
-        ProjectExpPageReqVO reqVO = new ProjectExpPageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setName(null);
-        reqVO.setStartTime(buildBetweenDate(2023, 2, 1, 2023, 2, 28));
-        reqVO.setEndTime(buildBetweenDate(2023, 2, 1, 2023, 2, 28));
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<ProjectExpDO> pageResult = projectExpService.getProjectExpPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbProjectExp, pageResult.getList().get(0));
-    }
-    public static LocalDate[] buildBetweenDate(int year1, int mouth1, int day1,
-                                               int year2, int mouth2, int day2) {
-        return new LocalDate[]{LocalDate.of(year1, mouth1, day1), LocalDate.of(year2, mouth2, day2)};
-    }
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/school/SchoolServiceImplTest.java

@@ -1,148 +0,0 @@
-package com.citu.module.menduner.system.service.school;
-
-import com.citu.module.menduner.system.controller.base.school.SchoolPageReqVO;
-import com.citu.module.menduner.system.controller.base.school.SchoolSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.school.SchoolDO;
-import com.citu.module.menduner.system.dal.mysql.school.SchoolMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_SCHOOL_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link SchoolServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(SchoolServiceImpl.class)
-public class SchoolServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private SchoolServiceImpl schoolService;
-
-    @Resource
-    private SchoolMapper schoolMapper;
-
-    @Test
-    public void testCreateSchool_success() {
-        // 准备参数
-        SchoolSaveReqVO createReqVO = randomPojo(SchoolSaveReqVO.class).setId(null);
-
-        // 调用
-        Long schoolId = schoolService.createSchool(createReqVO);
-        // 断言
-        assertNotNull(schoolId);
-        // 校验记录的属性是否正确
-        SchoolDO school = schoolMapper.selectById(schoolId);
-        assertPojoEquals(createReqVO, school, "id");
-    }
-
-    @Test
-    public void testUpdateSchool_success() {
-        // mock 数据
-        SchoolDO dbSchool = randomPojo(SchoolDO.class);
-        schoolMapper.insert(dbSchool);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        SchoolSaveReqVO updateReqVO = randomPojo(SchoolSaveReqVO.class, o -> {
-            o.setId(dbSchool.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        schoolService.updateSchool(updateReqVO);
-        // 校验是否更新正确
-        SchoolDO school = schoolMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, school);
-    }
-
-    @Test
-    public void testUpdateSchool_notExists() {
-        // 准备参数
-        SchoolSaveReqVO updateReqVO = randomPojo(SchoolSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> schoolService.updateSchool(updateReqVO), MDE_SCHOOL_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteSchool_success() {
-        // mock 数据
-        SchoolDO dbSchool = randomPojo(SchoolDO.class);
-        schoolMapper.insert(dbSchool);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbSchool.getId();
-
-        // 调用
-        schoolService.deleteSchool(id);
-       // 校验数据不存在了
-       assertNull(schoolMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteSchool_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> schoolService.deleteSchool(id), MDE_SCHOOL_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetSchoolPage() {
-       // mock 数据
-       SchoolDO dbSchool = randomPojo(SchoolDO.class, o -> { // 等会查询到
-           o.setName(null);
-           o.setAreaId(null);
-           o.setAddress(null);
-           o.setLongitude(null);
-           o.setLatitude(null);
-           o.setStatus(null);
-           o.setCreateTime(null);
-       });
-       schoolMapper.insert(dbSchool);
-       // 测试 name 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setName(null)));
-       // 测试 areaId 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setAreaId(null)));
-       // 测试 address 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setAddress(null)));
-       // 测试 longitude 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setLongitude(null)));
-       // 测试 latitude 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setLatitude(null)));
-       // 测试 status 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setStatus(null)));
-       // 测试 createTime 不匹配
-       schoolMapper.insert(cloneIgnoreId(dbSchool, o -> o.setCreateTime(null)));
-       // 准备参数
-       SchoolPageReqVO reqVO = new SchoolPageReqVO();
-       reqVO.setName(null);
-       reqVO.setAreaId(null);
-       reqVO.setAddress(null);
-       reqVO.setLongitude(null);
-       reqVO.setLatitude(null);
-       reqVO.setStatus(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<SchoolDO> pageResult = schoolService.getSchoolPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbSchool, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/skill/SkillServiceImplTest.java

@@ -1,138 +0,0 @@
-package com.citu.module.menduner.system.service.skill;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.skill.SkillListReqVO;
-import com.citu.module.menduner.system.controller.base.skill.SkillSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.skill.SkillDO;
-import com.citu.module.menduner.system.dal.mysql.skill.SkillMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-import java.util.List;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.SKILL_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link SkillServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(SkillServiceImpl.class)
-public class SkillServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private SkillServiceImpl skillService;
-
-    @Resource
-    private SkillMapper skillMapper;
-
-    @Test
-    public void testCreateSkill_success() {
-        // 准备参数
-        SkillSaveReqVO createReqVO = randomPojo(SkillSaveReqVO.class).setId(null);
-
-        // 调用
-        Long skillId = skillService.createSkill(createReqVO);
-        // 断言
-        assertNotNull(skillId);
-        // 校验记录的属性是否正确
-        SkillDO skill = skillMapper.selectById(skillId);
-        assertPojoEquals(createReqVO, skill, "id");
-    }
-
-    @Test
-    public void testUpdateSkill_success() {
-        // mock 数据
-        SkillDO dbSkill = randomPojo(SkillDO.class);
-        skillMapper.insert(dbSkill);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        SkillSaveReqVO updateReqVO = randomPojo(SkillSaveReqVO.class, o -> {
-            o.setId(dbSkill.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        skillService.updateSkill(updateReqVO);
-        // 校验是否更新正确
-        SkillDO skill = skillMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, skill);
-    }
-
-    @Test
-    public void testUpdateSkill_notExists() {
-        // 准备参数
-        SkillSaveReqVO updateReqVO = randomPojo(SkillSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> skillService.updateSkill(updateReqVO), SKILL_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteSkill_success() {
-        // mock 数据
-        SkillDO dbSkill = randomPojo(SkillDO.class);
-        skillMapper.insert(dbSkill);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbSkill.getId();
-
-        // 调用
-        skillService.deleteSkill(id);
-        // 校验数据不存在了
-        assertNull(skillMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteSkill_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> skillService.deleteSkill(id), SKILL_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetSkillList() {
-        // mock 数据
-        SkillDO dbSkill = randomPojo(SkillDO.class, o -> { // 等会查询到
-            o.setNameCn(null);
-            o.setNameEn(null);
-            o.setParentId(null);
-            o.setLevel(null);
-            o.setCreateTime(null);
-        });
-        skillMapper.insert(dbSkill);
-        // 测试 nameCn 不匹配
-        skillMapper.insert(cloneIgnoreId(dbSkill, o -> o.setNameCn(null)));
-        // 测试 nameEn 不匹配
-        skillMapper.insert(cloneIgnoreId(dbSkill, o -> o.setNameEn(null)));
-        // 测试 parentId 不匹配
-        skillMapper.insert(cloneIgnoreId(dbSkill, o -> o.setParentId(null)));
-        // 测试 level 不匹配
-        skillMapper.insert(cloneIgnoreId(dbSkill, o -> o.setLevel(null)));
-        // 测试 createTime 不匹配
-        skillMapper.insert(cloneIgnoreId(dbSkill, o -> o.setCreateTime(null)));
-        // 准备参数
-        SkillListReqVO reqVO = new SkillListReqVO();
-        reqVO.setNameCn(null);
-        reqVO.setNameEn(null);
-        reqVO.setParentId(null);
-        reqVO.setLevel(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        List<SkillDO> list = skillService.getSkillList(reqVO);
-        // 断言
-        assertEquals(1, list.size());
-        assertPojoEquals(dbSkill, list.get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/trainexp/TrainExpServiceImplTest.java

@@ -1,149 +0,0 @@
-package com.citu.module.menduner.system.service.trainexp;
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.trainexp.TrainExpPageReqVO;
-import com.citu.module.menduner.system.controller.base.trainexp.TrainExpSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.trainexp.TrainExpDO;
-import com.citu.module.menduner.system.dal.mysql.trainexp.TrainExpMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-import java.time.LocalDate;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.TRAIN_EXP_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link TrainExpServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(TrainExpServiceImpl.class)
-public class TrainExpServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private TrainExpServiceImpl trainExpService;
-
-    @Resource
-    private TrainExpMapper trainExpMapper;
-
-    public static LocalDate[] buildBetweenDate(int year1, int mouth1, int day1,
-                                               int year2, int mouth2, int day2) {
-        return new LocalDate[]{LocalDate.of(year1, mouth1, day1), LocalDate.of(year2, mouth2, day2)};
-    }
-
-    @Test
-    public void testCreateTrainExp_success() {
-        // 准备参数
-        TrainExpSaveReqVO createReqVO = randomPojo(TrainExpSaveReqVO.class).setId(null);
-
-        // 调用
-        Long trainExpId = trainExpService.createTrainExp(createReqVO);
-        // 断言
-        assertNotNull(trainExpId);
-        // 校验记录的属性是否正确
-        TrainExpDO trainExp = trainExpMapper.selectById(trainExpId);
-        assertPojoEquals(createReqVO, trainExp, "id");
-    }
-
-    @Test
-    public void testUpdateTrainExp_success() {
-        // mock 数据
-        TrainExpDO dbTrainExp = randomPojo(TrainExpDO.class);
-        trainExpMapper.insert(dbTrainExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        TrainExpSaveReqVO updateReqVO = randomPojo(TrainExpSaveReqVO.class, o -> {
-            o.setId(dbTrainExp.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        trainExpService.updateTrainExp(updateReqVO);
-        // 校验是否更新正确
-        TrainExpDO trainExp = trainExpMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, trainExp);
-    }
-
-    @Test
-    public void testUpdateTrainExp_notExists() {
-        // 准备参数
-        TrainExpSaveReqVO updateReqVO = randomPojo(TrainExpSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> trainExpService.updateTrainExp(updateReqVO), TRAIN_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteTrainExp_success() {
-        // mock 数据
-        TrainExpDO dbTrainExp = randomPojo(TrainExpDO.class);
-        trainExpMapper.insert(dbTrainExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbTrainExp.getId();
-
-        // 调用
-        trainExpService.deleteTrainExp(id);
-        // 校验数据不存在了
-        assertNull(trainExpMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteTrainExp_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> trainExpService.deleteTrainExp(id), TRAIN_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetTrainExpPage() {
-        // mock 数据
-        TrainExpDO dbTrainExp = randomPojo(TrainExpDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setStartTime(null);
-            o.setEndTime(null);
-            o.setOrgName(null);
-            o.setCourse(null);
-            o.setCreateTime(null);
-        });
-        trainExpMapper.insert(dbTrainExp);
-        // 测试 userId 不匹配
-        trainExpMapper.insert(cloneIgnoreId(dbTrainExp, o -> o.setUserId(null)));
-        // 测试 startTime 不匹配
-        trainExpMapper.insert(cloneIgnoreId(dbTrainExp, o -> o.setStartTime(null)));
-        // 测试 endTime 不匹配
-        trainExpMapper.insert(cloneIgnoreId(dbTrainExp, o -> o.setEndTime(null)));
-        // 测试 orgName 不匹配
-        trainExpMapper.insert(cloneIgnoreId(dbTrainExp, o -> o.setOrgName(null)));
-        // 测试 course 不匹配
-        trainExpMapper.insert(cloneIgnoreId(dbTrainExp, o -> o.setCourse(null)));
-        // 测试 createTime 不匹配
-        trainExpMapper.insert(cloneIgnoreId(dbTrainExp, o -> o.setCreateTime(null)));
-        // 准备参数
-        TrainExpPageReqVO reqVO = new TrainExpPageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setStartTime(buildBetweenDate(2023, 2, 1, 2023, 2, 28));
-        reqVO.setEndTime(buildBetweenDate(2023, 2, 1, 2023, 2, 28));
-        reqVO.setOrgName(null);
-        reqVO.setCourse(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<TrainExpDO> pageResult = trainExpService.getTrainExpPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbTrainExp, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/user/MdeUserServiceImplTest.java

@@ -1,144 +0,0 @@
-package com.citu.module.menduner.system.service.user;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.user.MdeUserPageReqVO;
-import com.citu.module.menduner.system.controller.base.user.MdeUserSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.user.MdeUserDO;
-import com.citu.module.menduner.system.dal.mysql.user.MdeUserMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_USER_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link MdeUserServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(MdeUserServiceImpl.class)
-public class MdeUserServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private MdeUserServiceImpl mdeUserService;
-
-    @Resource
-    private MdeUserMapper mdeUserMapper;
-
-    @Test
-    public void testCreateMdeUser_success() {
-        // 准备参数
-        MdeUserSaveReqVO createReqVO = randomPojo(MdeUserSaveReqVO.class).setId(null);
-
-        // 调用
-        Long mdeUserId = mdeUserService.createMdeUser(createReqVO);
-        // 断言
-        assertNotNull(mdeUserId);
-        // 校验记录的属性是否正确
-        MdeUserDO mdeUser = mdeUserMapper.selectById(mdeUserId);
-        assertPojoEquals(createReqVO, mdeUser, "id");
-    }
-
-    @Test
-    public void testUpdateMdeUser_success() {
-        // mock 数据
-        MdeUserDO dbMdeUser = randomPojo(MdeUserDO.class);
-        mdeUserMapper.insert(dbMdeUser);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        MdeUserSaveReqVO updateReqVO = randomPojo(MdeUserSaveReqVO.class, o -> {
-            o.setId(dbMdeUser.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        mdeUserService.updateMdeUser(updateReqVO);
-        // 校验是否更新正确
-        MdeUserDO mdeUser = mdeUserMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, mdeUser);
-    }
-
-    @Test
-    public void testUpdateMdeUser_notExists() {
-        // 准备参数
-        MdeUserSaveReqVO updateReqVO = randomPojo(MdeUserSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> mdeUserService.updateMdeUser(updateReqVO), MDE_USER_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteMdeUser_success() {
-        // mock 数据
-        MdeUserDO dbMdeUser = randomPojo(MdeUserDO.class);
-        mdeUserMapper.insert(dbMdeUser);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbMdeUser.getId();
-
-        // 调用
-        mdeUserService.deleteMdeUser(id);
-        // 校验数据不存在了
-        assertNull(mdeUserMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteMdeUser_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> mdeUserService.deleteMdeUser(id), MDE_USER_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetMdeUserPage() {
-        // mock 数据
-        MdeUserDO dbMdeUser = randomPojo(MdeUserDO.class, o -> { // 等会查询到
-            o.setUsername(null);
-            o.setEmail(null);
-            o.setPhone(null);
-            o.setStatus(null);
-            o.setLoginIp(null);
-            o.setCreateTime(null);
-        });
-        mdeUserMapper.insert(dbMdeUser);
-        // 测试 username 不匹配
-        mdeUserMapper.insert(cloneIgnoreId(dbMdeUser, o -> o.setUsername(null)));
-        // 测试 email 不匹配
-        mdeUserMapper.insert(cloneIgnoreId(dbMdeUser, o -> o.setEmail(null)));
-        // 测试 phone 不匹配
-        mdeUserMapper.insert(cloneIgnoreId(dbMdeUser, o -> o.setPhone(null)));
-        // 测试 status 不匹配
-        mdeUserMapper.insert(cloneIgnoreId(dbMdeUser, o -> o.setStatus(null)));
-        // 测试 loginIp 不匹配
-        mdeUserMapper.insert(cloneIgnoreId(dbMdeUser, o -> o.setLoginIp(null)));
-        // 测试 createTime 不匹配
-        mdeUserMapper.insert(cloneIgnoreId(dbMdeUser, o -> o.setCreateTime(null)));
-        // 准备参数
-        MdeUserPageReqVO reqVO = new MdeUserPageReqVO();
-        reqVO.setUsername(null);
-        reqVO.setEmail(null);
-        reqVO.setPhone(null);
-        reqVO.setStatus(null);
-        reqVO.setLoginIp(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<MdeUserDO> pageResult = mdeUserService.getMdeUserPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbMdeUser, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/user/UserAccountServiceImplTest.java

@@ -1,132 +0,0 @@
-package com.citu.module.menduner.system.service.user;
-
-
-import com.citu.framework.common.pojo.PageResult;
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-import com.citu.module.menduner.system.controller.base.user.account.UserAccountPageReqVO;
-import com.citu.module.menduner.system.controller.base.user.account.UserAccountSaveReqVO;
-import com.citu.module.menduner.system.dal.dataobject.user.UserAccountDO;
-import com.citu.module.menduner.system.dal.mysql.user.UserAccountMapper;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.springframework.context.annotation.Import;
-
-import javax.annotation.Resource;
-
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
-import static com.citu.framework.common.util.object.ObjectUtils.cloneIgnoreId;
-import static com.citu.framework.test.core.util.AssertUtils.assertPojoEquals;
-import static com.citu.framework.test.core.util.AssertUtils.assertServiceException;
-import static com.citu.framework.test.core.util.RandomUtils.randomLongId;
-import static com.citu.framework.test.core.util.RandomUtils.randomPojo;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.USER_ACCOUNT_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link UserAccountServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(UserAccountServiceImpl.class)
-public class UserAccountServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private UserAccountServiceImpl userAccountService;
-
-    @Resource
-    private UserAccountMapper userAccountMapper;
-
-    @Test
-    public void testCreateUserAccount_success() {
-        // 准备参数
-        UserAccountSaveReqVO createReqVO = randomPojo(UserAccountSaveReqVO.class).setId(null);
-
-        // 调用
-        Long userAccountId = userAccountService.createUserAccount(createReqVO);
-        // 断言
-        assertNotNull(userAccountId);
-        // 校验记录的属性是否正确
-        UserAccountDO userAccount = userAccountMapper.selectById(userAccountId);
-        assertPojoEquals(createReqVO, userAccount, "id");
-    }
-
-    @Test
-    public void testUpdateUserAccount_success() {
-        // mock 数据
-        UserAccountDO dbUserAccount = randomPojo(UserAccountDO.class);
-        userAccountMapper.insert(dbUserAccount);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        UserAccountSaveReqVO updateReqVO = randomPojo(UserAccountSaveReqVO.class, o -> {
-            o.setId(dbUserAccount.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        userAccountService.updateUserAccount(updateReqVO);
-        // 校验是否更新正确
-        UserAccountDO userAccount = userAccountMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, userAccount);
-    }
-
-    @Test
-    public void testUpdateUserAccount_notExists() {
-        // 准备参数
-        UserAccountSaveReqVO updateReqVO = randomPojo(UserAccountSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userAccountService.updateUserAccount(updateReqVO), USER_ACCOUNT_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteUserAccount_success() {
-        // mock 数据
-        UserAccountDO dbUserAccount = randomPojo(UserAccountDO.class);
-        userAccountMapper.insert(dbUserAccount);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbUserAccount.getId();
-
-        // 调用
-        userAccountService.deleteUserAccount(id);
-        // 校验数据不存在了
-        assertNull(userAccountMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteUserAccount_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> userAccountService.deleteUserAccount(id), USER_ACCOUNT_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetUserAccountPage() {
-        // mock 数据
-        UserAccountDO dbUserAccount = randomPojo(UserAccountDO.class, o -> { // 等会查询到
-            o.setUserId(null);
-            o.setBalance(null);
-            o.setCreateTime(null);
-        });
-        userAccountMapper.insert(dbUserAccount);
-        // 测试 userId 不匹配
-        userAccountMapper.insert(cloneIgnoreId(dbUserAccount, o -> o.setUserId(null)));
-        // 测试 balance 不匹配
-        userAccountMapper.insert(cloneIgnoreId(dbUserAccount, o -> o.setBalance(null)));
-        // 测试 createTime 不匹配
-        userAccountMapper.insert(cloneIgnoreId(dbUserAccount, o -> o.setCreateTime(null)));
-        // 准备参数
-        UserAccountPageReqVO reqVO = new UserAccountPageReqVO();
-        reqVO.setUserId(null);
-        reqVO.setBalance(null);
-        reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-        // 调用
-        PageResult<UserAccountDO> pageResult = userAccountService.getUserAccountPage(reqVO);
-        // 断言
-        assertEquals(1, pageResult.getTotal());
-        assertEquals(1, pageResult.getList().size());
-        assertPojoEquals(dbUserAccount, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-im-biz/src/test/java/com/citu/module/menduner/system/service/workexp/WorkExpServiceImplTest.java

@@ -1,170 +0,0 @@
-package com.citu.module.menduner.system.service.workexp;
-
-import com.citu.module.menduner.system.controller.base.workexp.WorkExpPageReqVO;
-import com.citu.module.menduner.system.controller.base.workexp.WorkExpSaveReqVO;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-
-import javax.annotation.Resource;
-
-import com.citu.framework.test.core.ut.BaseDbUnitTest;
-
-import com.citu.module.menduner.system.dal.dataobject.workexp.WorkExpDO;
-import com.citu.module.menduner.system.dal.mysql.workexp.WorkExpMapper;
-import com.citu.framework.common.pojo.PageResult;
-
-import org.springframework.context.annotation.Import;
-
-import java.time.LocalDateTime;
-
-import static com.citu.framework.test.core.util.AssertUtils.*;
-import static com.citu.framework.test.core.util.RandomUtils.*;
-import static com.citu.framework.common.util.date.LocalDateTimeUtils.*;
-import static com.citu.framework.common.util.object.ObjectUtils.*;
-import static com.citu.module.menduner.system.enums.ErrorCodeConstants.MDE_WORK_EXP_NOT_EXISTS;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * {@link WorkExpServiceImpl} 的单元测试类
- *
- * @author Rayson
- */
-@Import(WorkExpServiceImpl.class)
-public class WorkExpServiceImplTest extends BaseDbUnitTest {
-
-    @Resource
-    private WorkExpServiceImpl workExpService;
-
-    @Resource
-    private WorkExpMapper workExpMapper;
-
-    @Test
-    public void testCreateWorkExp_success() {
-        // 准备参数
-        WorkExpSaveReqVO createReqVO = randomPojo(WorkExpSaveReqVO.class).setId(null);
-
-        // 调用
-        Long workExpId = workExpService.createWorkExp(createReqVO);
-        // 断言
-        assertNotNull(workExpId);
-        // 校验记录的属性是否正确
-        WorkExpDO workExp = workExpMapper.selectById(workExpId);
-        assertPojoEquals(createReqVO, workExp, "id");
-    }
-
-    @Test
-    public void testUpdateWorkExp_success() {
-        // mock 数据
-        WorkExpDO dbWorkExp = randomPojo(WorkExpDO.class);
-        workExpMapper.insert(dbWorkExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        WorkExpSaveReqVO updateReqVO = randomPojo(WorkExpSaveReqVO.class, o -> {
-            o.setId(dbWorkExp.getId()); // 设置更新的 ID
-        });
-
-        // 调用
-        workExpService.updateWorkExp(updateReqVO);
-        // 校验是否更新正确
-        WorkExpDO workExp = workExpMapper.selectById(updateReqVO.getId()); // 获取最新的
-        assertPojoEquals(updateReqVO, workExp);
-    }
-
-    @Test
-    public void testUpdateWorkExp_notExists() {
-        // 准备参数
-        WorkExpSaveReqVO updateReqVO = randomPojo(WorkExpSaveReqVO.class);
-
-        // 调用, 并断言异常
-        assertServiceException(() -> workExpService.updateWorkExp(updateReqVO), MDE_WORK_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    public void testDeleteWorkExp_success() {
-        // mock 数据
-        WorkExpDO dbWorkExp = randomPojo(WorkExpDO.class);
-        workExpMapper.insert(dbWorkExp);// @Sql: 先插入出一条存在的数据
-        // 准备参数
-        Long id = dbWorkExp.getId();
-
-        // 调用
-        workExpService.deleteWorkExp(id);
-       // 校验数据不存在了
-       assertNull(workExpMapper.selectById(id));
-    }
-
-    @Test
-    public void testDeleteWorkExp_notExists() {
-        // 准备参数
-        Long id = randomLongId();
-
-        // 调用, 并断言异常
-        assertServiceException(() -> workExpService.deleteWorkExp(id), MDE_WORK_EXP_NOT_EXISTS);
-    }
-
-    @Test
-    @Disabled  // TODO 请修改 null 为需要的值，然后删除 @Disabled 注解
-    public void testGetWorkExpPage() {
-       // mock 数据
-       WorkExpDO dbWorkExp = randomPojo(WorkExpDO.class, o -> { // 等会查询到
-           o.setUserId(null);
-           o.setEnterpriseId(null);
-           o.setEnterpriseName(null);
-           o.setIndustryId(null);
-           o.setDeptName(null);
-           o.setPositionId(null);
-           o.setPositionName(null);
-           o.setStartTime(null);
-           o.setEndTime(null);
-           o.setPayUnit(null);
-           o.setCurrencyType(null);
-           o.setCreateTime(null);
-       });
-       workExpMapper.insert(dbWorkExp);
-       // 测试 userId 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setUserId(null)));
-       // 测试 enterpriseId 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setEnterpriseId(null)));
-       // 测试 enterpriseName 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setEnterpriseName(null)));
-       // 测试 industryId 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setIndustryId(null)));
-       // 测试 deptName 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setDeptName(null)));
-       // 测试 positionId 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setPositionId(null)));
-       // 测试 positionName 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setPositionName(null)));
-       // 测试 startTime 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setStartTime(null)));
-       // 测试 endTime 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setEndTime(null)));
-       // 测试 payUnit 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setPayUnit(null)));
-       // 测试 currencyType 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setCurrencyType(null)));
-       // 测试 createTime 不匹配
-       workExpMapper.insert(cloneIgnoreId(dbWorkExp, o -> o.setCreateTime(null)));
-       // 准备参数
-       WorkExpPageReqVO reqVO = new WorkExpPageReqVO();
-       reqVO.setUserId(null);
-       reqVO.setEnterpriseId(null);
-       reqVO.setEnterpriseName(null);
-       reqVO.setIndustryId(null);
-       reqVO.setDeptName(null);
-       reqVO.setPositionId(null);
-       reqVO.setPositionName(null);
-       reqVO.setStartTime(LocalDateTime.now());
-       reqVO.setEndTime(LocalDateTime.now());
-       reqVO.setPayUnit(null);
-       reqVO.setCurrencyType(null);
-       reqVO.setCreateTime(buildBetweenTime(2023, 2, 1, 2023, 2, 28));
-
-       // 调用
-       PageResult<WorkExpDO> pageResult = workExpService.getWorkExpPage(reqVO);
-       // 断言
-       assertEquals(1, pageResult.getTotal());
-       assertEquals(1, pageResult.getList().size());
-       assertPojoEquals(dbWorkExp, pageResult.getList().get(0));
-    }
-
-}

menduner/menduner-system-biz/pom.xml

@@ -31,6 +31,12 @@
             <version>${revision}</version>
         </dependency>
 
+        <dependency>
+            <groupId>com.citu</groupId>
+            <artifactId>citu-spring-boot-starter-es</artifactId>
+            <version>${revision}</version>
+        </dependency>
+
         <dependency>
             <groupId>com.xingyuv</groupId>
             <artifactId>spring-boot-starter-captcha-plus</artifactId> <!-- 验证码，一般用于登录使用 -->