Java单元测试框架使用指南(Version:1.2.3)

<project>
<properties>
    <java.version>8</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

    <!-- 单元测试依赖 jar 包 -->
    <junit.version>5.10.1</junit.version>
    <junit-jupiter.version>5.10.1</junit-jupiter.version>
    <mockito.version>4.11.0</mockito.version>
    <easyexcel.version>3.3.3</easyexcel.version>
    <reflectasm.version>1.11.9</reflectasm.version>
    <byte-buddy.version>1.14.10</byte-buddy.version>
    <antlr4.version>4.9.3</antlr4.version>
    <fastjson.version>2.0.45</fastjson.version>
    <caffeine.version>2.9.3</caffeine.version>
    <h2database.version>2.2.224</h2database.version>
</properties>
<dependencies>
<!-- SpringBoot项目开始 -->
<!-- 添加 SpringBoot 测试支持,并排除 JUnit4 相关的类，防止类冲突  -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
      <exclusions>
        <exclusion>
          <groupId>org.junit.vintage</groupId>
          <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
      </exclusions>
    </dependency>
<!-- SpringBoot项目结束 -->
<!-- 单元测试框架依赖开始 -->
        <!-- 添加 JUnit 支持,必须使用 5.10.1 及以上版本 -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- 添加 Mock 的支持 -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-junit-jupiter</artifactId>
            <version>${mockito.version}</version>
            <exclusions>
                <!-- 排除 mockito-junit-jupiter 内的 mockito-core -->
                <exclusion>
                    <groupId>org.mockito</groupId>
                    <artifactId>mockito-core</artifactId>
                </exclusion>
            </exclusions>
            <scope>test</scope>
        </dependency>
        <!-- 将 mockito-core 替换为 mockito-inline ，用于支持静态方法的 Mock -->
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-inline</artifactId>
            <version>${mockito.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy</artifactId>
            <version>${byte-buddy.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy-agent</artifactId>
            <version>${byte-buddy.version}</version>
            <scope>test</scope>
        </dependency>
        <!-- 测试框架使用 Excel 作为参数化数据源，故而依赖EasyExcel 包 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>${easyexcel.version}</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-params</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.esotericsoftware</groupId>
            <artifactId>reflectasm</artifactId>
            <version>${reflectasm.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <!-- 添加内存数据库 h2database 支持，使用兼容 MYSQL 的内存模式 -->
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <version>${h2database.version}</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>${caffeine.version}</version>
        </dependency>
<!-- 单元测试框架依赖结束 -->
</dependencies>
</project>

# ---------数据源配置-----------
spring.datasource.driver-class-name=org.h2.Driver
# MODE=MYSQL 配置开启MYSQL语法兼容模式，IGNORECASE=忽略表及字段的大小写，DB_CLOSE_ON_EXIT=单元测试完成后关闭内存数据库,NON_KEYWORDS=将列出的关键词不视为关键字
spring.datasource.url=jdbc:h2:mem:unit_demo;DB_CLOSE_DELAY=-1;IGNORECASE=TRUE;DB_CLOSE_ON_EXIT=TRUE;MODE=MYSQL;NON_KEYWORDS=USER
spring.datasource.username=sa
spring.datasource.password=

# SQL脚本配置项
spring.sql.init.platform=h2
spring.sql.init.encoding=UTF-8
# 初始化模式，always=每次都重新初始化数据库
spring.sql.init.mode=always
# 如果在初始化数据库时发生错误，是否停止
spring.sql.init.continue-on-error=false

# ---------- H2 控制台配置 开启后可以通过本地 WEB访问数据库 --------------
spring.h2.console.path=/h2
# 是否启用控制台
spring.h2.console.enabled=true

CREATE TABLE `tmp_table_h2` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT 'id',
   `name` varchar(255) NOT NULL COMMENT '名称',
   `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
   PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 COMMENT='临时表（切勿删除）';

INSERT INTO `tmp_table_h2`(`name`,`create_time`)VALUES ('测试数据',now());

package top.yjp.testing;

import top.yjp.testing.annotation.ExcelInject;
import top.yjp.testing.db.DataSourceProvider;
import top.yjp.testing.db.DatabaseOperator;
import top.yjp.testing.db.provider.H2DataSourceProvider;
import top.yjp.testing.junit.DbBuilder;
import top.yjp.testing.junit.Maker;
import top.yjp.testing.junit.Mocker;
import top.yjp.testing.junit.Validator;

import javax.sql.DataSource;

public class BaseTest {
    @ExcelInject
    protected DbBuilder builder;
    @ExcelInject
    protected Mocker mocker;
    @ExcelInject
    protected Maker maker;

    @ExcelInject
    protected DatabaseOperator operator;
    @ExcelInject
    protected Validator validator;

    private DataSource dataSource=null;
    @ExcelInject
    public DataSource getDataSource(){
        if(this.dataSource==null){
            // 此处可以替换为各个项目的获取数据源的实现
            String url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1;IGNORECASE=TRUE;DB_CLOSE_ON_EXIT=TRUE;MODE=MYSQL";
            String user = "sa";
            String password = "";
            H2DataSourceProvider provider = new H2DataSourceProvider();
            provider.setUrl(url);
            provider.setUser(user);
            provider.setPassword(password);
            this.dataSource =provider.getDataSource();
        }
        return this.dataSource;
    }
}

package top.yjp.testing.antlr4;
@Slf4j
@ExcelConfiguration
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
@ExtendWith(JTFExtension.class)
@DisplayName("ANTLR4断言表达式测试")
// ⚠️注意：请将 @ExtendWith(JTFExtension.class) 放在最靠近方法声明的行或位于 @ExtendWith(MockitoExtension.class) 之下
// 无论是否需要 Mock 都请按照如上固定格式使用注解
public class AntlrExpressionTest extends BaseTest {
    @Mock
    private MockOrderService mockOrderService;
    @InjectMocks
    private MockOrderLogic mockOrderLogic;

    @TestTemplate
    @DisplayName("使用Excel: 1次测试所有断言表达式")
    public void testAllExpressionsFromExcelFile(Map<String, String> map) {
        if(map==null){
            throw new RuntimeException("Excel初始化错误!");
        }
        log.info("{}",map);
        // 此处开始写业务测试代码并将业务返回对象或捕获的业务异常添加到 validator 对象
        // 添加 Exception 对象
        RuntimeException re = new RuntimeException("运行时错误");
        validator.addSingleObject(re);
        // 执行业务代码测试及
        this.validator.validate();
    }
}

host: localhost
port: 3306
user: root
pass: test
database: test

# windows
# 查看参数帮助
m2h.exe export -h
# 直接导出
m2h.exe export

package top.yjp.testing.annotation;

import top.yjp.testing.strategy.ExcelFileNameStrategy;
import top.yjp.testing.strategy.NullExcelFileNameStrategy;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface ExcelConfiguration {
    /**
     * 默认的 Excel 配置信息
     * 注解到 JUnit 单元测试类上，配置各个表的相关属性
     */
    ExcelConfig[] value() default {
            @ExcelConfig(value = ExcelConfigType.TEST_DATA, fetchType = FetchType.COLUMN_NAME_MAP),
            @ExcelConfig(value = ExcelConfigType.DB_DATA, fetchType = FetchType.COLUMN_NAME_MAP),
            @ExcelConfig(value = ExcelConfigType.MOCK_DATA, fetchType = FetchType.COLUMN_NAME_MAP),
            @ExcelConfig(value = ExcelConfigType.DEFAULT_OBJECT_DATA, fetchType = FetchType.COLUMN_NAME_MAP)
    };

    // 默认值 @DbAction(DbActionType.REBUILD) 是重新构建数据库
    // @DbAction(DbActionType.NONE) 则是什么都不做，即不会重新构建数据库
    DbAction dbAction() default @DbAction(DbActionType.REBUILD);

    // 默认的 Excel 文件名生成策略，默认是空的，将会优先取 @ExcelFileSource 配置的 Excel 文件名生成策略
    // 如果@ExcelConfiguration和@ExcelFileSource中的strategy()都是空的，则会用 @ExcelFileSource的 file 等基本信息定义 Excel 文件。
    Class<? extends ExcelFileNameStrategy> strategy() default NullExcelFileNameStrategy.class;

    /**
     * 默认 Excel 文件是必须的,当你需要一次性测试（非参数化测试）的时候，又想依旧是用当前配置好的内存数据库，那么你可以将
     * excelFileRequired 设置为 false。这样将不会要求 Excel 文件存在。
     */
    boolean excelFileRequired() default true;
}

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
@Slf4j
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
@ExcelConfiguration
@ExtendWith(JTFExtension.class)
public class JDateTimeTest extends BaseTest {
    @TestTemplate
    public void testSaveJDateTimeToH2Database(Map<String,String> map){
        log.info("Map={}",map);
    }
}

package top.yjp.jtf.ext.jodd.suite.time;

import jodd.datetime.JDateTime;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import top.yjp.jtf.core.annotation.ExcelConfiguration;
import top.yjp.jtf.core.db.jdbc.JdbcDbOperator;
import top.yjp.jtf.core.junit.extension.JTFExtension;
import top.yjp.jtf.core.junit.factory.DefaultInitFactory;
import top.yjp.jtf.ext.jodd.base.BaseTest;
import top.yjp.jtf.ext.jodd.base.H2DataSource;
import top.yjp.jtf.ext.jodd.db.JoddSqlGenerator;
import top.yjp.jtf.ext.jodd.entity.JoddUser;

import java.time.LocalDateTime;
import java.util.Map;

@Slf4j
@ExcelConfiguration(excelFileRequired = false)
@ExtendWith(JTFExtension.class)
public class JDateTimeTest extends BaseTest {
    @TestTemplate
    public void testSaveJDateTimeToH2Database(Map<String,String> map){
        String id = "10";
        JoddUser user = new JoddUser();
        user.setId(id);
        user.setRealName("于先生");
        user.setProvince("广东省");
        user.setCity("广州市");
        user.setRegisterTime(LocalDateTime.now());
        user.setUpdateTime(new JDateTime());
        user.setCreateTime(new JDateTime());
        user.setRegisterFrom(5);
        operator.save(user);
        JoddUser dbUser =  operator.findById(JoddUser.class,id);
        log.info("DbUser={}",dbUser);
        Assertions.assertEquals(user.getUpdateTime(),dbUser.getUpdateTime());
        Assertions.assertEquals(user,dbUser);
    }

    @TestTemplate
    public void testDemo(Map<String,String> map){
        log.info("这个类里可以写多个测试方法,并且每个方法只会执行1次，不同方法执行前仍旧会进行重置数据库等操作");
    }
}

import javax.sql.DataSource;
public class Test{
    private DataSource dataSource = null;
    @ExcelInject
    public DataSource getDataSource(){
        if(this.dataSource==null){
            // this.dataSource = new ...;
        }
        return this.dataSource;
    }
}

    @VariableInject
    public void inject(Variable variable){
        variable.addVar("company","昆山巨星行动电子商务有限公司");
        variable.addVar("today", LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE));
    }

    @BeforeMock
    public void beforeMock(Mocker mocker){
        // 明确设定 Mock 表达式 skuProductService.queryItemProductQuantity 是 Map<Long, Map<String, ProductDto>>
        mocker.setMockMethodReturnType("skuProductService.queryItemProductQuantity", new TypeReference<Map<Long, Map<String, ProductDto>>>() {});
        // 明确设定 Mock 表达式 stargoUtil.sendCloudDelivery2 是 HxDeliveryResp<HxDeliveryData>
        mocker.setMockMethodReturnType("stargoUtil.sendCloudDelivery2", new TypeReference<HxDeliveryResp<HxDeliveryData>>() {});
    }

StockLogisticsItem[price=StockLogistics[name="测试商品",sku="SKU100"].price].price==StockLogistics[name="测试商品",sku="SKU3"].price

StockLogisticsItem[price=StockLogistics[name="测试商品",sku="SKU100"].price].sum(price)==StockLogistics[name="测试商品",sku="SKU3"].sum(price)

StockLogisticsItem[price=StockLogistics[name="商品名称:价格是100.11的测试商品SKU5"].sum(price)].price==StockLogistics[name="测试商品",sku="SKU3"].price

StockLogistics[name="测试商品"].size()==3

StockLogistics[name="测试商品",sku="SKU100"].size()==1

StockLogistics[name="没有这个测试商品",sku="SKU100"].size()==0

StockLogistics[name="测试商品"].sum(price)!=211.22

StockLogistics[name="测试商品",sku="SKU100"].sum(price)==100.11

//如下一条肯定测试不通过，没有任何一个 price 是 9.9 的，所有的测试数据的 price>=100
//StockLogistics[name="测试商品",sku="SKU100"].sum(price)==9.9

//orderId="${orderId}" 支持变量名的方式断言
StockLogistics[id=1].sum(price)==StockLogistics[id=1].price

// 测试 Class["id"].FunctionCall 形式是否正确
StockLogistics["1"].sum(price)==StockLogistics[id=1].price

StockLogistics["没有这个测试商品"].size()==0

StockLogistics.id==1

StockLogistics.id=="1"

StockLogistics.id!=2

StockLogistics.id!="2"

// 如下是 null 值计算，由于 null 是 ANTLR 的关键字，直接写会报错，故而 null 值统一用 "null"来代替
StockLogistics["没有这个测试商品"].sum(abc)=="null"
StockLogistics["没有这个测试商品"].sum(abc123)=="null"

// 断言表达式的右边可以是数组型，目前只支持数组内的元素是基本java对象（如数字、字符串）
Cat.names==["Iris","Andy"]

// @since 1.1.30
"基本字符串"=="基本字符串"
${company}=="巨星行动电子商务优先公司"

// @since 1.1.33
// 可以使用Bean的多级属性求值的方式进行断言，注意不支持Map的操作，只支持JavaBean。若属性名不存在的话，则会直接抛出异常。
User.name=="于金平"
User.company.name=="巨星行动"
User[name="林小姐"].company.name=="友邦保险"
User[name="没有这个用户"].size()==0
User[name="没有这个用户"].company=="null"
User[name="没有这个用户"].company.name=="null"

// @since 1.1.38
// 可以使用Bean的list属性进行过滤并求值。若过滤条件找不到任何符合条件的值，则返回null值。使用如下演示数据
// 部门数据 departments=[{id:1,name:"人事部"},{id:2,name:"后勤部"}]
// 雇员数据 employees=[{id:1,name:"老大"},{id:2,name:"王二"},{id:3,name:"张三"},{id:4,name:"李四"}]
// 注意： 1.1.38 暂不支持多级属性值的方法调用，比如Company.test.departments[id="1"].size()==2不支持
Company.departments[name="后勤部"].employees[name="李四"].id==4L
Company.departments[id="1"].name=="人事部"
Company.departments[id="1"].employees[name="王二"].name=="王二"
Company.departments[id="1"].employees[name="王二"].name==Company.employees[id="2"].name

    @VariableInject
    public void inject(Variable variable){
        variable.addVar("company","昆山巨星行动电子商务有限公司");
        variable.addVar("today", LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE));
        variable.addVar("date", LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE)+" 00:00:00");

        // 1.1.43 版本新增允许加入 JavaBean 对象,例如：User对象
        variable.addVar("user",new User());
    }

    @Mock
    private JackyunDeliveryService jackyunDeliveryService = new JackyunDeliveryServiceImpl();
    // 类型：com.dmj.util.SpringContextUtils
    @Mock
    private static SpringContextUtils springContextUtils = new SpringContextUtils();

    @Mock
    private static StringUtils stringUtils = new StringUtils();

    // Validator
    String orderNo="从业务系统获取的订单号";
    validator.addVar("orderNo",orderNo);
    // 从版本 1.143 开始允许简单变量的值是JavaBean，并且可以在 Excel 表中使用属性路径的方式应用该变量的属性值。
    validator.addVar("user",new User());

    validator.validate();

    // Excel断言可以使用如下类似形式的断言
    // ${orderNo}=="从业务系统获取的订单号"
    // MockOrder[orderNo="${orderNo}"].orderNo=="从业务系统获取的订单号"
    // "${user.address.province.name}"=="广东省"

    public static String uuid(){
        return UUID.randomUUID().toString();
    }

@Slf4j
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
@ExcelConfiguration
@ExtendWith(JTFExtension.class)
@DisplayName("Mock测试")
public class MockTest extends BaseTest {
    // 定义 IdUtil的静态mock实例
    private static MockedStatic<IdUtil> mockedStatic;
    // 定义数据索引
    private static AtomicInteger callCount=new AtomicInteger(0);
    // 定义已知要提供的数据
    private static String[] uuids = new String[]{"value1","value2","value3"};
    @BeforeAll
    public static void setup(){
        mockedStatic = Mockito.mockStatic(IdUtil.class);
        mockedStatic.when(()->IdUtil.uuid()).then((Answer<String>) invocation -> uuids[callCount.getAndAdd(1)]);
    }
    @TestTemplate
    void testMock(Map<String,String> map){
        callCount.set(0); //重设索引值
        Assertions.assertEquals("value1",IdUtil.uuid()); // 断言第1次获取的的是 value1
        Assertions.assertEquals("value2",IdUtil.uuid()); // 断言第2次获取的的是 value2
        Assertions.assertEquals("value3",IdUtil.uuid()); // 断言第3次获取的的是 value3
    }
}

    public static String format(Integer i,String format){
        return String.format("%d",i);
    }

    public static String format(Long i,String format){
        return String.format("%dL",i);
    }

# 对于使用 DbExpect 列进行断言的时候，如果出现找不到 数据库实体类Class 的时候，请加入如下配置
ScanClassInitFactory =top.yjp.jtf.core.junit.factory.ScanClassInitFactory

# 若你需要在线程中使已Mock的静态方法生效，请加入如下配置
MockInitFactory = top.yjp.jtf.core.junit.factory.MockInitFactory

// @BeforeMock 注解的方法，将在Mock各个对象之前运行
@BeforeMock
public void beforeMock(Mocker mocker){
    // setMockMethodReturnType 有2个参数，用来设置 mock 表达式的返回类型
    // 第一个参数是 mock 表达式的字符串
    // 第二个参数是该 mock 表达式的返回类型
    mocker.setMockMethodReturnType("skuProductService.queryItemProductQuantity", new TypeReference<Map<Long, Map<String, ProductDto>>>() {});
    mocker.setMockMethodReturnType("stargoUtil.sendCloudDelivery2", new TypeReference<HxDeliveryResp<HxDeliveryData>>() {});
}

// 此处我们假设在单元测试代码里需要 Mock 阿里支付的SDK
@Mock
private AlipayBaseService alipayBaseService;

public void doTest(Map<String,String> params){
    // 首先声明，你需要捕获的参数的类，本例中是 AlipayMerchantOrderSyncRequest
    ArgumentCaptor<AlipayMerchantOrderSyncRequest> captor = ArgumentCaptor.forClass(AlipayMerchantOrderSyncRequest.class);

    // 调用你的业务方法，该方法中调用了阿里支付的SDK
    alipayBaseService.merchantOrderSync(payOrder, notifyStatus);

    // 校验 alipayBaseService 这个mock对象中，执行了1次（具体几次视你的业务而定）merchantOrderSync方法，并捕获这个方法的参数到 captor,这个步骤必须要有verify
    // 若你需要捕获多个参数值，则需要定义多个 ArgumentCaptor 与函数参数一一对应，并且如下代码也需要增加对应的 *.capture()的方法调用。
    Mockito.verify(alipayBaseService, Mockito.times(1)).merchantOrderSync(captor.capture());
    // 将捕获的参数值取出放到内存变量
    AlipayMerchantOrderSyncRequest orderEvent = captor.getValue();
    // 将请求参数加入到内存变量验证队列，并在Excel文件中撰写断言即可
    validator.addSingleObject(orderEvent);
}

public class BaseTest {

    @ExcelInject
    protected RedisOperator redisOperator;

    @ExcelInject
    public RedisDbConfig createRedisDbConfig(){
        // 此处使用的是默认读取 classpath://redis-db-config.properties 配置，你也可以硬编码实现 或者直接读取 SpringBoot的 redis 配置信息
        DefaultRedisDbConfigProvider provider = new DefaultRedisDbConfigProvider();
        return provider.getRedisDbConfig();
    }
}

redis.host=10.30.10.225
redis.port=6379
redis.password=gd34O1NT0nqibqv1fo
# 注意：最后的键值格式 TEST_项目代号_时间键值，中间是用英文下划线分割的,前缀不包含格式中的第2个下划线，所以最终实际前缀是 TEST_JTF_
redis.keyPrefix=TEST_JTF

redis.host=10.10.10.217
redis.port=6379
redis.password=eien39ynu1UTIi19t3buvq
# 注意：最后的键值格式 TEST_项目代号_时间键值，中间是用英文下划线分割的,前缀不包含格式中的第2个下划线，所以最终实际前缀是 TEST_JTF_
redis.keyPrefix=TEST_JTF

package top.yjp.jtf.core.suite.redis;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import top.yjp.jtf.core.BaseTest;
import top.yjp.jtf.core.annotation.EnableRedis;
import top.yjp.jtf.core.annotation.ExcelConfiguration;
import top.yjp.jtf.core.junit.extension.JTFExtension;

import java.util.Map;

@Slf4j
@EnableRedis
@ExcelConfiguration
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
@ExtendWith(JTFExtension.class)
public class RedisTest extends BaseTest {

    @BeforeEach
    public void beforeEach(){
        // 你可以在 @BeforeEach 方法内对 Redis执行写操作，jtf框架会在你写操作前清除该Redis库中所有带有已配置前缀的KEY值
        for(int i=3000;i<3100;i++){
            String key = String.valueOf(i);
            // 注意： 若你使用 redisOperator 则set方法其键不包括配置的前缀，若你使用SpringBoot的RedisTemplate 或 自定义的RedisUtil 则需要使用带有前缀的KEY
            redisOperator.set(key,String.valueOf(i));
        }
    }
    @TestTemplate
    public void testRedis(Map<String,String> map){
        for(int i=3000;i<3100;i++){
            String key = String.valueOf(i);
            String dbValue =redisOperator.get(key);
            // 注意： 若你使用 redisOperator 则get方法其键不包括配置的前缀，若你使用SpringBoot的RedisTemplate 或 自定义的RedisUtil 则需要使用带有前缀的KEY
            Assertions.assertEquals(dbValue,String.valueOf(i));
        }
    }
}

{
  "name": "于先生",
  "address": {
    "location": "国际采购中心",
    "province": {
        "name": "广东省"
    },
    "city": {
        "name": "广州市"
    }
  }
}

package top.yjp.jtf.core.tools;

public class JtfTools {
    /**
     * 生成指定表建表语句,忽略掉所有索引、外键等
     * @param tableName 表名
     */
    public static void m2h(String tableName) {
        MySqlH2 m2h = new MySqlH2();
        m2h.setUrl("jdbc:mysql://10.30.10.213:3306/jxyx_shop");
        m2h.setUsername("mdjkjxyx");
        m2h.setPassword("tiyn36urvVQV5");
        m2h.setDatabaseName("jxyx_shop");
        // 若你的工程需要独特的类型替换等操作，请打开如下注释代码
        // 文本文件格式 每一行用=号分割，左边是旧字符串，右边是新字符串
        // 如果是放在classpath下，则请用classpath:开头
        m2h.setReplaceFile("classpath:MySqlH2.txt");

        m2h.printTable(tableName);
    }

    public static void main(String[] args) {
        // 是否是打印数据库表
        boolean printTable = false;

        // 打印JSON时是否使用格式化功能
        boolean prettyFormat = false;

        String tableName = "app_user_md";
        String className = "top.yjp.ext.spring.suite.express.MockExpressionTestBean";
        if (printTable) {
            m2h(tableName);
        } else{
            EntityToJson.printJson(className,prettyFormat);
        }
    }
}

MybatisPlusException: can not find lambda cache for this property [****]

# 要求 jtf 框架升级到 >=1.1.25 版本
# 解决 MybatisPlus的 Mapper在 Mock 后抛出 MybatisPlusException 的Bug. 在配置文件最后添加如下配置
top.yjp.jtf.core.junit.MockHook=top.yjp.jtf.ext.spring.mock.MybatisPlusMockHook

# 要求 jtf 框架升级到 >=1.1.47 版本
# 如果你在SpringBoot项目中的数据库实体类使用了Enum类型，请将如下配置增加到 top.yjp.jtf.core.junit.InitFactory.properties 中
# 增加后将会对Enum类型进行值转换
SpringSqlParameterValueInitFactory=top.yjp.jtf.ext.spring.factory.SpringSqlParameterValueInitFactory

-- 实际上 create_time是实体类中的JDateTime类型，其值转换为INSERT SQL 缺少单引号包裹，故而生成了如下错误的SQL语句
INSERT INTO table_name(id,username,create_time)values (1,'admin',2024-07-29 20:50:00);

import org.mockito.Mock;
import top.yjp.jtf.ext.jodd.util.JoddReflectUtil;

@DisplayName("微信订单取消单元测试")
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
@ExcelConfiguration
@ExtendWith(JTFExtension.class)
public class OrderCancelJunit extends BaseJunitTest {
    // 将 WxSdkService 类标记为 mock
    @Mock
    WxSdkService wxSdkService;

    // 注入 Jodd Bean
    @PetiteInject
    UserOrderService userOrderService;

    @DisplayName("微信订单取消单元测试")
    @TestTemplate
    public void cancelOrder(Map<String, String> map) {
        log.info("MAP={}",map);
        String userId=map.get("userId");
        String orderId=map.get("orderId");


        //注意：Jodd mock 需要增加如下一行代码的替换操作
        // 使用已mock的 wxSdkService 替换掉 jodd 注入的wxSdkService，此方法必须在业务方法执行之前调用。
        JoddReflectUtil.setPropertyValue(userOrderService, "wxOrderService.wxSdkService", wxSdkService);


        //
        // 假设我们测试的业务是用户userId的order订单进行微信退款操作，执行业务处理
        RefundResult result = userOrderService.refund(userId,orderId);


        validator.addSingleObject(result);
        validator.validate();
    }
}