Back to Repositories

Testing BPM Task Candidate Expression Strategy in ruoyi-vue-pro

A comprehensive unit test suite for BpmTaskCandidateExpressionStrategy, validating expression-based task candidate calculations in the Flowable BPM engine. This test class ensures proper evaluation of user expressions for task assignments and activity calculations.

Test Coverage Overview

The test suite provides targeted coverage for expression-based task candidate calculations.

Key areas tested include:

User calculation by task using expression evaluation
User calculation by activity with process variables
Expression parsing and evaluation in BPM context

Edge cases cover null parameters and empty expressions, while integration points focus on Flowable engine interaction.

Implementation Analysis

The testing approach utilizes Mockito’s static mocking capabilities to isolate FlowableUtils dependencies.

Key patterns include:

MockedStatic usage for utility class testing
DelegateExecution mocking for Flowable context simulation
Assertion-based verification of calculated user sets

Technical Details

Testing stack includes:

JUnit Jupiter for test execution
Mockito for mocking and verification
BaseMockitoUnitTest as the base test class
FlowableUtils for BPM engine utilities

Configuration uses @InjectMocks for dependency injection and @Test for test case identification.

Best Practices Demonstrated

The test suite exemplifies high-quality testing practices through precise test isolation and thorough verification.

Notable practices include:

Resource cleanup with try-with-resources for MockedStatic
Clear test method naming conventions
Separate test cases for distinct functionality
Proper mock verification and assertion patterns

yunaiv/ruoyi-vue-pro

yudao-module-bpm/yudao-module-bpm-biz/src/test/java/cn/iocoder/yudao/module/bpm/framework/flowable/core/candidate/strategy/other/BpmTaskCandidateExpressionStrategyTest.java

            
package cn.iocoder.yudao.module.bpm.framework.flowable.core.candidate.strategy.other;

import cn.iocoder.yudao.framework.test.core.ut.BaseMockitoUnitTest;
import cn.iocoder.yudao.module.bpm.framework.flowable.core.util.FlowableUtils;
import org.flowable.engine.delegate.DelegateExecution;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.MockedStatic;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import static cn.iocoder.yudao.framework.common.util.collection.SetUtils.asSet;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;

@Disabled // TODO 芋艿：临时注释
public class BpmTaskCandidateExpressionStrategyTest extends BaseMockitoUnitTest {

    @InjectMocks
    private BpmTaskCandidateExpressionStrategy strategy;

    @Test
    public void testCalculateUsersByTask() {
        try (MockedStatic<FlowableUtils> flowableUtilMockedStatic = mockStatic(FlowableUtils.class)) {
            // 准备参数
            String param = "1,2";
            DelegateExecution execution = mock(DelegateExecution.class);
            // mock 方法
            flowableUtilMockedStatic.when(() -> FlowableUtils.getExpressionValue(same(execution), eq(param)))
                    .thenReturn(asSet(1L, 2L));

            // 调用
            Set<Long> results = strategy.calculateUsersByTask(execution, param);
            // 断言
            assertEquals(asSet(1L, 2L), results);
        }
    }

    @Test
    public void testCalculateUsersByActivity() {
        try (MockedStatic<FlowableUtils> flowableUtilMockedStatic = mockStatic(FlowableUtils.class)) {
            // 准备参数
            String param = "1,2";
            Map<String, Object> processVariables = new HashMap<>();
            // mock 方法
            flowableUtilMockedStatic.when(() -> FlowableUtils.getExpressionValue(same(processVariables), eq(param)))
                    .thenReturn(asSet(1L, 2L));

            // 调用
            Set<Long> results = strategy.calculateUsersByActivity(null, null, param,
                    null, null, processVariables);
            // 断言
            assertEquals(asSet(1L, 2L), results);
        }
    }

}