package jnpf.flowable.service.dev;
|
|
import jnpf.base.UserInfo;
|
import jnpf.base.entity.VisualdevEntity;
|
import jnpf.permission.entity.UserEntity;
|
import jnpf.flowable.model.candidates.CandidateListModel;
|
import jnpf.exception.WorkFlowException;
|
import jnpf.flowable.entity.*;
|
import jnpf.flowable.model.candidates.CandidateCheckVo;
|
import jnpf.flowable.model.task.FlowModel;
|
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
|
import jnpf.flowable.model.util.DevApprovalActor;
|
import jnpf.flowable.service.OperatorService;
|
import jnpf.flowable.service.TaskService;
|
import jnpf.flowable.util.*;
|
import jnpf.util.UserProvider;
|
import org.junit.Test;
|
import org.mockito.MockedStatic;
|
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
|
import static org.junit.Assert.*;
|
import static org.mockito.ArgumentMatchers.*;
|
import static org.mockito.Mockito.*;
|
|
public class DevApprovalServiceTest {
|
@org.junit.BeforeClass public static void context() {
|
jnpf.util.context.SpringContext.setApplicationContext(mock(org.springframework.context.ApplicationContext.class));
|
}
|
private final DevApprovalSignatures signatures = mock(DevApprovalSignatures.class);
|
private final DevApprovalProperties properties = new DevApprovalProperties();
|
private final FlowUtil flow = mock(FlowUtil.class);
|
private final OperatorUtil operators = mock(OperatorUtil.class);
|
private final OperatorService operatorService = mock(OperatorService.class);
|
private final TaskService tasks = mock(TaskService.class);
|
private final ServiceUtil forms = mock(ServiceUtil.class);
|
private final DevApprovalLocks locks = mock(DevApprovalLocks.class);
|
private final DevApprovalStep step = mock(DevApprovalStep.class);
|
private final DevApprovalService service = new DevApprovalService(properties, flow, operators, operatorService, tasks, forms, locks, step, signatures, mock(jnpf.base.DictionaryDataApi.class));
|
private final TaskEntity task = new TaskEntity();
|
private final NodeModel node = new NodeModel();
|
private final OperatorEntity operator = new OperatorEntity();
|
private final TemplateNodeEntity definition = new TemplateNodeEntity();
|
|
private void enableLocalRuntime() {
|
var environment = new org.springframework.core.env.StandardEnvironment();
|
environment.setActiveProfiles("workflow-dev-tools");
|
properties.setRuntime(environment);
|
}
|
|
private void ready() throws Exception {
|
enableLocalRuntime();
|
DevApprovalSignature signature = new DevApprovalSignature(); signature.setId("signed"); signature.setUserId("signer");
|
when(signatures.require("task", "signed")).thenReturn(signature);
|
UserEntity signer = new UserEntity(); signer.setId("signer"); signer.setEnabledMark(1);
|
when(forms.getUserInfo(anyString())).thenReturn(signer);
|
VisualdevEntity release = new VisualdevEntity(); release.setFormData("{\"fields\":[]}");
|
when(forms.getReleaseInfo("form")).thenReturn(release);
|
properties.setEnabled(true);
|
properties.setEnvironment("development");
|
properties.setFormIds(Set.of("form"));
|
task.setId("task"); task.setFlowId("flow-v2"); task.setStatus(1);
|
node.setType("approver"); node.setNodeId("review");
|
definition.setNodeCode("review"); definition.setFormId("form"); definition.setNodeJson("{}");
|
TemplateNodeEntity start = new TemplateNodeEntity(); start.setNodeType("start"); start.setFormId("form");
|
doAnswer(call -> {
|
FlowModel model = call.getArgument(1);
|
model.setTaskEntity(task);
|
model.setNodeEntityList(Arrays.asList(start, definition));
|
model.setNodes(new HashMap<>(Map.of("review", node, "global", new NodeModel())));
|
return null;
|
}).when(flow).setFlowModel(eq("task"), any());
|
operator.setId("op"); operator.setTaskId("task"); operator.setNodeCode("review");
|
operator.setNodeId("node"); operator.setNodeName("质量审核"); operator.setHandleId("original-user");
|
operator.setStatus(1); operator.setCompletion(0);
|
when(operatorService.getList("task")).thenReturn(List.of(operator));
|
when(forms.infoData("form", "task")).thenReturn(new HashMap<>(Map.of("name", "saved")));
|
when(tasks.checkCandidates(eq("op"), any())).thenReturn(new CandidateCheckVo());
|
when(tasks.getInfo("task")).thenReturn(task);
|
when(locks.lock(anyString(), anyString(), anyLong(), any(TimeUnit.class))).thenReturn(true);
|
}
|
|
private MockedStatic<UserProvider> admin() {
|
MockedStatic<UserProvider> users = mockStatic(UserProvider.class);
|
UserInfo user = new UserInfo(); user.setUserId("admin"); user.setIsAdministrator(true);
|
users.when(UserProvider::getUser).thenReturn(user);
|
users.when(UserProvider::getLoginUserId).thenReturn("admin");
|
return users;
|
}
|
|
@Test public void disabledByDefaultAndRequiresExplicitDevelopment() {
|
enableLocalRuntime();
|
assertFalse(properties.available());
|
properties.setEnabled(true); assertFalse(properties.available());
|
properties.setEnvironment("development"); assertTrue(properties.available());
|
properties.setFormIds(Set.of("form")); assertTrue(properties.available());
|
properties.setEnvironment("production"); assertFalse(properties.available());
|
}
|
|
@Test public void productionOrMissingProfileCannotEnableEvenWithFlag() {
|
properties.setEnabled(true); properties.setEnvironment("development");
|
assertFalse(properties.available());
|
var env = new org.springframework.core.env.StandardEnvironment();
|
properties.setRuntime(env);
|
for (String[] profiles : List.of(new String[]{}, new String[]{"production"},
|
new String[]{"workflow-dev-tools", "production"}, new String[]{"workflow-dev-tools", "prod"})) {
|
env.setActiveProfiles(profiles); assertFalse(properties.available());
|
}
|
env.setActiveProfiles("workflow-dev-tools"); assertTrue(properties.available());
|
}
|
|
@Test public void nonAdministratorCannotInspectOrAdvance() throws Exception {
|
ready();
|
try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
|
UserInfo user = new UserInfo(); user.setIsAdministrator(false);
|
users.when(UserProvider::getUser).thenReturn(user);
|
assertFalse(service.inspect("task", "signed").isEnabled());
|
try { service.approve("task", "op", "signed"); fail(); } catch (WorkFlowException expected) { }
|
verifyNoInteractions(flow, step, locks);
|
}
|
}
|
|
@Test public void nonAllowlistedFormIsNotOperated() throws Exception {
|
ready(); properties.setFormIds(Set.of("other"));
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertFalse(service.inspect("task", "signed").isEnabled());
|
assertEquals("BLOCKED", service.approve("task", "op", "signed").getStatus());
|
verifyNoInteractions(step);
|
}
|
}
|
|
@Test public void buttonAvailabilityDoesNotReadFormsOrCalculateCandidates() throws Exception {
|
ready();
|
clearInvocations(forms, tasks, operatorService);
|
when(forms.infoData("form", "task")).thenThrow(new IllegalStateException("form unavailable"));
|
clearInvocations(forms);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
DevApprovalService.State state = service.inspect("task", null);
|
assertTrue(state.isEnabled());
|
assertEquals("READY", state.getStatus());
|
verifyNoInteractions(forms, tasks, operatorService, step);
|
try {
|
service.inspect("task", "signed");
|
fail("Signed inspection must still read and validate the form");
|
} catch (IllegalStateException expected) {
|
assertEquals("form unavailable", expected.getMessage());
|
}
|
}
|
}
|
|
@Test public void emptyAllowlistApprovesOtherWorkflowAndNodeForms() throws Exception {
|
ready(); properties.setFormIds(Set.of());
|
definition.setFormId("other-node-form");
|
when(forms.infoData("other-node-form", "task")).thenReturn(new HashMap<>(Map.of("name", "saved")));
|
VisualdevEntity release = forms.getReleaseInfo("form");
|
when(forms.getReleaseInfo("other-node-form")).thenReturn(release);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertTrue(service.inspect("task", "signed").isEnabled());
|
assertEquals("ADVANCED", service.approve("task", "op", "signed").getStatus());
|
verify(step).approve(eq(operator), any(), eq("signer"));
|
}
|
}
|
|
@Test public void missingRequiredFieldNamesNodeAndFieldWithoutApproving() throws Exception {
|
ready(); node.setFormOperates(List.of(Map.of("id", "reason", "name", "修订原因", "required", true)));
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
DevApprovalService.State result = service.approve("task", "op", "signed");
|
assertEquals("质量审核", result.getNodeName());
|
assertEquals("BLOCKED", result.getStatus());
|
assertTrue(result.getProblems().get(0).contains("修订原因"));
|
verifyNoInteractions(step);
|
}
|
}
|
|
@Test public void signatureCannotBeFabricated() throws Exception {
|
ready(); node.setHasSign(true);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertTrue(service.approve("task", "op", "signed").getProblems().get(0).contains("手写签名"));
|
verifyNoInteractions(step);
|
}
|
}
|
|
@Test public void candidateSelectionStopsBeforeMutation() throws Exception {
|
ready(); CandidateCheckVo choice = new CandidateCheckVo(); choice.setType(2);
|
when(tasks.checkCandidates(anyString(), any())).thenReturn(choice);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertEquals("BLOCKED", service.approve("task", "op", "signed").getStatus());
|
verifyNoInteractions(step);
|
}
|
}
|
|
@Test public void candidateAndApprovalActorUseVerifiedSignerInsteadOfAdmin() throws Exception {
|
ready(); CandidateCheckVo choice = new CandidateCheckVo(); choice.setType(2);
|
CandidateListModel next = new CandidateListModel(); next.setNodeCode("next"); next.setIsCandidates(true);
|
choice.setList(List.of(next)); when(tasks.checkCandidates(anyString(), any())).thenReturn(choice);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertEquals("ADVANCED", service.approve("task", "op", "signed").getStatus());
|
org.mockito.ArgumentCaptor<FlowModel> capture = org.mockito.ArgumentCaptor.forClass(FlowModel.class);
|
verify(step).approve(eq(operator), capture.capture(), eq("signer"));
|
assertEquals(List.of("signer"), capture.getValue().getCandidateList().get("next"));
|
assertEquals("signed", capture.getValue().getFormData().get("biz_sign"));
|
}
|
}
|
|
@Test public void requiredTextIsFilledFromPublishedSchemaAndExistingValuesSurvive() throws Exception {
|
ready(); node.setFormOperates(List.of(Map.of("id", "reason", "name", "原因", "required", true)));
|
VisualdevEntity release = new VisualdevEntity(); release.setFormData("{\"fields\":[{\"__vModel__\":\"reason\",\"__config__\":{\"jnpfKey\":\"input\"}}]}");
|
when(forms.getReleaseInfo("form")).thenReturn(release);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertEquals("ADVANCED", service.approve("task", "op", "signed").getStatus());
|
org.mockito.ArgumentCaptor<FlowModel> capture = org.mockito.ArgumentCaptor.forClass(FlowModel.class);
|
verify(step).approve(eq(operator), capture.capture(), eq("signer"));
|
assertEquals("已输入", capture.getValue().getFormData().get("reason"));
|
assertEquals("saved", capture.getValue().getFormData().get("name"));
|
}
|
}
|
|
@Test public void frontendCustomValidationIsNotSilentlySkipped() throws Exception {
|
ready(); definition.setNodeJson("{\"approveFuncConfig\":{\"validateFuncConfig\":{\"on\":true}}}");
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertEquals("BLOCKED", service.approve("task", "op", "signed").getStatus());
|
verifyNoInteractions(step);
|
}
|
}
|
|
@Test public void changedPendingIdDoesNotApproveDifferentOperator() throws Exception {
|
ready();
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
try { service.approve("task", "stale", "signed"); fail(); } catch (WorkFlowException expected) { }
|
verifyNoInteractions(step);
|
verify(locks).unlock(eq("dev-approve:task"), anyString());
|
}
|
}
|
|
@Test public void nativeNodeLockPreventsConcurrentApproval() throws Exception {
|
ready(); when(locks.lock(eq("tasknode"), anyString(), anyLong(), any())).thenReturn(false);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
try { service.approve("task", "op", "signed"); fail(); } catch (WorkFlowException expected) { }
|
verifyNoInteractions(step);
|
verify(locks, never()).unlock(eq("tasknode"), anyString());
|
}
|
}
|
|
@Test public void successfulStepKeepsCallbacksAndDoesNotSweepUncheckedNodes() throws Exception {
|
ready();
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertEquals("ADVANCED", service.approve("task", "op", "signed").getStatus());
|
org.mockito.InOrder order = inOrder(step, operators);
|
order.verify(step).approve(eq(operator), any(), eq("signer"));
|
order.verify(operators).handleOperator();
|
order.verify(operators).handleTaskStatusThenEvent();
|
order.verify(operators).launchTrigger(any());
|
order.verify(operators).handleTaskStatus();
|
verify(operators, never()).autoAudit(any(FlowModel.class));
|
assertEquals("original-user", operator.getHandleId());
|
verify(forms, times(1)).infoData("form", "task");
|
verify(tasks, times(1)).checkCandidates(eq("op"), any());
|
}
|
}
|
|
@Test public void failureCompensatesAndDoesNotReportSuccessOrSendCompletionEvents() throws Exception {
|
ready(); doThrow(new WorkFlowException("业务校验失败")).when(step).approve(any(), any(), anyString());
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
try { service.approve("task", "op", "signed"); fail(); } catch (WorkFlowException expected) { }
|
verify(operators).compensate(task);
|
verify(operators, never()).handleTaskStatusThenEvent();
|
verify(locks).unlock(eq("tasknode"), anyString());
|
}
|
}
|
|
@Test public void staleEngineTaskReportsRecoveryWithoutRetryingApproval() throws Exception {
|
ready(); doThrow(new WorkFlowException("任务不存在")).when(step).approve(any(), any(), anyString());
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
try { service.approve("task", "op", "signed"); fail(); }
|
catch (WorkFlowException expected) { assertTrue(expected.getMessage().contains("已执行待办恢复")); }
|
verify(step, times(1)).approve(any(), any(), anyString());
|
verify(operators).compensate(task);
|
verify(operators, never()).handleTaskStatusThenEvent();
|
}
|
}
|
|
@Test public void failedCompensationDoesNotClaimTaskRecovered() throws Exception {
|
ready(); doThrow(new WorkFlowException("任务不存在")).when(step).approve(any(), any(), anyString());
|
doThrow(new WorkFlowException("引擎不可用")).when(operators).compensate(task);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
try { service.approve("task", "op", "signed"); fail(); }
|
catch (WorkFlowException expected) {
|
assertTrue(expected.getMessage().contains("恢复未完成"));
|
assertTrue(expected.getMessage().contains("任务不存在"));
|
assertFalse(expected.getMessage().contains("已执行待办恢复"));
|
}
|
verify(step, times(1)).approve(any(), any(), anyString());
|
verify(operators, never()).handleTaskStatusThenEvent();
|
}
|
}
|
|
@Test public void completedTaskIsIdempotent() throws Exception {
|
ready(); task.setStatus(2);
|
try (MockedStatic<UserProvider> ignored = admin()) {
|
assertEquals("PASSED", service.approve("task", "op", "signed").getStatus());
|
verifyNoInteractions(step);
|
}
|
}
|
|
@Test public void attributionIsScopedToOneOperatorAndAlwaysCleared() {
|
assertEquals("assigned", DevApprovalActor.resolve("op", "assigned"));
|
try (DevApprovalActor ignored = DevApprovalActor.open("op", "admin")) {
|
assertEquals("admin", DevApprovalActor.resolve("op", "assigned"));
|
assertEquals("assigned", DevApprovalActor.resolve("other", "assigned"));
|
}
|
assertEquals("assigned", DevApprovalActor.resolve("op", "assigned"));
|
}
|
|
@Test public void pendingExcludesUnactivatedAndPreviouslyHandledOperators() {
|
operator.setStatus(-2); assertFalse(DevApprovalService.pending(operator));
|
operator.setStatus(1); assertTrue(DevApprovalService.pending(operator));
|
operator.setHandleStatus(1); assertFalse(DevApprovalService.pending(operator));
|
}
|
}
|
