package jnpf.flowable.util;
|
|
import jnpf.base.UserInfo;
|
import jnpf.base.model.flow.FlowFormDataModel;
|
import jnpf.exception.WorkFlowException;
|
import jnpf.flowable.entity.*;
|
import jnpf.flowable.enums.TaskStatusEnum;
|
import jnpf.flowable.mapper.*;
|
import jnpf.flowable.model.flowable.FlowAbleUrl;
|
import jnpf.flowable.model.task.FlowModel;
|
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
|
import jnpf.flowable.model.util.FlowStatusHolder;
|
import jnpf.flowable.model.util.TaskInitiatorPermission;
|
import jnpf.flowable.service.FilePermissionSnapshotService;
|
import jnpf.util.UserProvider;
|
import jnpf.util.context.SpringContext;
|
import org.junit.*;
|
import org.mockito.MockedStatic;
|
import org.springframework.context.ApplicationContext;
|
|
import java.lang.reflect.Constructor;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicReference;
|
|
import static org.junit.Assert.*;
|
import static org.mockito.ArgumentMatchers.*;
|
import static org.mockito.Mockito.*;
|
|
/** 调用真实暂存/提交分支，外部持久化和引擎边界使用替身。 */
|
public class WorkflowDraftLifecycleTest {
|
private final Map<Class<?>, Object> dependencies = new HashMap<>();
|
private final AtomicReference<TaskEntity> stored = new AtomicReference<>();
|
private final AtomicReference<UserInfo> currentUser = new AtomicReference<>();
|
private MockedStatic<UserProvider> users;
|
private TaskMapper tasks;
|
private ServiceUtil forms;
|
private FilePermissionSnapshotService snapshots;
|
private FlowUtil flow;
|
private OperatorUtil operator;
|
|
@Before public void setUp() throws Exception {
|
SpringContext.setApplicationContext(mock(ApplicationContext.class));
|
currentUser.set(user("owner"));
|
users = mockStatic(UserProvider.class);
|
users.when(UserProvider::getUser).thenAnswer(call -> currentUser.get());
|
users.when(UserProvider::getLoginUserId).thenAnswer(call -> currentUser.get().getUserId());
|
tasks = dependency(TaskMapper.class);
|
forms = dependency(ServiceUtil.class);
|
snapshots = dependency(FilePermissionSnapshotService.class);
|
flow = spy(construct(FlowUtil.class));
|
dependencies.put(FlowUtil.class, flow);
|
operator = spy(construct(OperatorUtil.class));
|
when(tasks.selectById(anyString())).thenAnswer(call -> stored.get());
|
when(tasks.insert(any(TaskEntity.class))).thenAnswer(call -> {
|
stored.set(call.getArgument(0));
|
return 1;
|
});
|
when(tasks.updateById(any(TaskEntity.class))).thenReturn(1);
|
doAnswer(call -> {
|
((TaskEntity) call.getArgument(0)).setFilePermissionSnapshot("draft-snapshot");
|
return null;
|
}).when(snapshots).prepareNewTask(any(), anyString(), anyMap());
|
TemplateEntity template = new TemplateEntity();
|
template.setId("template"); template.setFlowId("version"); template.setFullName("测试流程"); template.setType(0);
|
TemplateJsonEntity version = new TemplateJsonEntity();
|
version.setId("version"); version.setTemplateId("template"); version.setVersion("1"); version.setFlowableId("deployment");
|
when(dependency(TemplateJsonMapper.class).selectById("version")).thenReturn(version);
|
when(dependency(TemplateMapper.class).getInfo("template")).thenReturn(template);
|
TemplateNodeEntity global = new TemplateNodeEntity();
|
global.setNodeCode("global"); global.setNodeType("global");
|
global.setNodeJson("{\"type\":\"global\",\"defaultContent\":\"测试流程\"}");
|
TemplateNodeEntity start = new TemplateNodeEntity();
|
start.setNodeCode("start"); start.setNodeType("start"); start.setFormId("form");
|
start.setNodeJson("{\"type\":\"start\",\"nodeId\":\"start\",\"nodeName\":\"发起\"}");
|
when(dependency(TemplateNodeMapper.class).getList("version")).thenReturn(List.of(global, start));
|
}
|
|
@After public void tearDown() {
|
users.close();
|
FlowStatusHolder.clear();
|
}
|
|
@Test public void menuFirstSaveCreatesOwnedTaskBeforeSavingFormWithoutStartingEngine() throws Exception {
|
FlowModel model = draft(0);
|
operator.saveOrSubmit(model);
|
TaskEntity task = stored.get();
|
assertNotNull(task);
|
assertEquals(Integer.valueOf(0), task.getStatus());
|
assertEquals("owner", task.getCreatorUserId());
|
assertNotNull(task.getCreatorTime());
|
assertNull(task.getInstanceId());
|
assertNull(task.getStartTime());
|
assertEquals("draft-snapshot", task.getFilePermissionSnapshot());
|
org.mockito.InOrder order = inOrder(snapshots, tasks, forms);
|
order.verify(snapshots).prepareNewTask(eq(task), eq("version"), anyMap());
|
order.verify(tasks).insert(task);
|
order.verify(forms).saveOrUpdateFormData(argThat(data -> task.getId().equals(data.getId())
|
&& Boolean.TRUE.equals(data.getSkipRequiredValidation())));
|
verifyNoInteractions(dependency(FlowAbleUrl.class), dependency(RecordMapper.class),
|
dependency(NodeRecordMapper.class), dependency(OperatorMapper.class));
|
}
|
|
@Test public void flowLaunchFirstSaveUsesSameDraftTaskContract() throws Exception {
|
operator.saveOrSubmit(draft(1));
|
assertEquals(Integer.valueOf(0), stored.get().getStatus());
|
assertEquals("owner", stored.get().getCreatorUserId());
|
verify(tasks).insert(any(TaskEntity.class));
|
verify(forms).saveOrUpdateFormData(argThat(data -> Boolean.TRUE.equals(data.getSkipRequiredValidation())));
|
}
|
|
@Test public void repeatedMenuSaveReusesIdCreatorTimeAndSnapshot() throws Exception {
|
FlowModel model = draft(0);
|
operator.saveOrSubmit(model);
|
TaskEntity task = stored.get();
|
Date created = task.getCreatorTime();
|
model.setId(task.getId());
|
operator.saveOrSubmit(model);
|
assertEquals(task.getId(), model.getTaskEntity().getId());
|
assertEquals("owner", task.getCreatorUserId());
|
assertSame(created, task.getCreatorTime());
|
assertEquals("draft-snapshot", task.getFilePermissionSnapshot());
|
assertNotNull(task.getLastModifyTime());
|
verify(tasks, times(1)).insert(any(TaskEntity.class));
|
verify(tasks, times(1)).updateById(any(TaskEntity.class));
|
verify(snapshots, times(1)).prepareNewTask(any(), anyString(), anyMap());
|
verify(forms, times(2)).saveOrUpdateFormData(argThat(data -> Boolean.TRUE.equals(data.getSkipRequiredValidation())));
|
}
|
|
@Test public void delegateSaveKeepsOriginalCreatorAndDelegate() throws Exception {
|
FlowModel model = draft(0);
|
operator.saveOrSubmit(model);
|
TaskEntity task = stored.get(); task.setDelegateUserId("delegate");
|
currentUser.set(user("delegate"));
|
model.setId(task.getId()); model.setUserInfo(currentUser.get());
|
model.setUserId("delegate"); model.setDelegateUser("forged-replacement");
|
operator.saveOrSubmit(model);
|
assertEquals("owner", task.getCreatorUserId());
|
assertEquals("delegate", task.getDelegateUserId());
|
assertEquals("delegate", task.getLastModifyUserId());
|
}
|
|
@Test public void otherUserCannotSaveEvenIfBusinessApplicantOrRequestedCreatorMatches() throws Exception {
|
FlowModel model = draft(0);
|
operator.saveOrSubmit(model);
|
currentUser.set(user("stranger"));
|
model.setId(stored.get().getId()); model.setUserInfo(currentUser.get()); model.setUserId("stranger");
|
model.getFormData().put("shenqing_ren_id", "stranger");
|
try { operator.saveOrSubmit(model); fail("must reject another user's draft"); }
|
catch (WorkFlowException expected) { }
|
verify(forms, times(1)).saveOrUpdateFormData(any(FlowFormDataModel.class));
|
verify(tasks, never()).updateById(any(TaskEntity.class));
|
assertEquals("owner", stored.get().getCreatorUserId());
|
}
|
|
@Test public void failedTaskInsertDoesNotSaveBusinessForm() throws Exception {
|
when(tasks.insert(any(TaskEntity.class))).thenReturn(0);
|
try { operator.saveOrSubmit(draft(0)); fail("must fail the save"); }
|
catch (WorkFlowException expected) { }
|
verify(forms, never()).saveOrUpdateFormData(any(FlowFormDataModel.class));
|
}
|
|
@Test public void submissionStartsEngineAndUpdatesOriginalDraftInsteadOfInsertingAnotherTask() throws Exception {
|
FlowModel model = draft(0);
|
operator.saveOrSubmit(model);
|
String id = stored.get().getId();
|
model.setId(id); model.setStatus(TaskStatusEnum.RUNNING.getCode());
|
// 即使携带自动草稿标记，正式提交也必须恢复必填校验。
|
model.setServerAutoDraft(true);
|
when(dependency(FlowAbleUrl.class).startInstance(eq("deployment"), anyMap())).thenReturn("engine-instance");
|
when(forms.infoData("form", id)).thenReturn(new HashMap<>());
|
doNothing().when(flow).create(any(FlowModel.class), anyString(), anyList(), any());
|
doNothing().when(flow).createLaunchUser(anyString(), anyString());
|
doReturn(Collections.emptyList()).when(operator).handleOperator(any(FlowModel.class));
|
doNothing().when(operator).systemAudit();
|
operator.saveOrSubmit(model);
|
assertEquals(id, stored.get().getId());
|
assertEquals(Integer.valueOf(1), stored.get().getStatus());
|
assertEquals("engine-instance", stored.get().getInstanceId());
|
assertNotNull(stored.get().getStartTime());
|
assertEquals("owner", stored.get().getCreatorUserId());
|
verify(tasks, times(1)).insert(any(TaskEntity.class));
|
verify(snapshots, times(1)).prepareNewTask(any(), anyString(), anyMap());
|
verify(dependency(FlowAbleUrl.class), times(1)).startInstance(eq("deployment"), anyMap());
|
verify(forms).saveOrUpdateFormData(argThat(data -> Boolean.TRUE.equals(data.getSkipRequiredValidation())));
|
verify(forms).saveOrUpdateFormData(argThat(data -> !Boolean.TRUE.equals(data.getSkipRequiredValidation())));
|
}
|
|
|
@Test public void revisionAttachmentFailureBeforeEngineStartLeavesExistingDraftUntouched() throws Exception {
|
FlowModel model = draft(0); operator.saveOrSubmit(model);
|
model.setId(stored.get().getId()); model.setStatus(TaskStatusEnum.RUNNING.getCode());
|
var guard = dependency(jnpf.flowable.service.DmsLifecycleSubmissionGuard.class);
|
when(guard.beforeSave(anyString(), anyString(), eq(1), anyMap())).thenAnswer(call -> {
|
model.getFormData().put(jnpf.flowable.model.filepermission.DmsRevisionAttachmentCheck.REQUIRED, true);
|
return true;
|
});
|
doThrow(new WorkFlowException("修订附件内容不同")).when(forms).saveOrUpdateFormData(any());
|
try { operator.saveOrSubmit(model); fail("must reject changed content"); }
|
catch (WorkFlowException expected) { assertTrue(expected.getMessage().contains("附件")); }
|
verifyNoInteractions(dependency(jnpf.flowable.service.DmsLifecycleEngineRecovery.class), dependency(FlowAbleUrl.class));
|
verify(tasks, never()).updateById(any(TaskEntity.class));
|
assertEquals(Integer.valueOf(0), stored.get().getStatus());
|
}
|
|
@Test public void ownerAndDelegateCanDeleteButOtherUserCannot() throws Exception {
|
TaskEntity task = new TaskEntity(); task.setId("task"); task.setStatus(0);
|
task.setCreatorUserId("owner"); task.setDelegateUserId("delegate");
|
when(tasks.getOrderStaList(anyList())).thenReturn(List.of(task));
|
TaskUtil deletion = spy(construct(TaskUtil.class));
|
doNothing().when(deletion).delete(anyList());
|
deletion.delete(List.of("task"), false);
|
currentUser.set(user("delegate")); deletion.delete(List.of("task"), false);
|
currentUser.set(user("stranger"));
|
try { deletion.delete(List.of("task"), false); fail("must reject deletion"); }
|
catch (WorkFlowException expected) { }
|
verify(deletion, times(2)).delete(anyList());
|
}
|
|
@Test public void taskOwnershipFailsClosedWithoutIdentityOrTask() {
|
TaskEntity task = new TaskEntity(); task.setCreatorUserId("owner"); task.setDelegateUserId("delegate");
|
assertTrue(TaskInitiatorPermission.canOperate(task, "owner"));
|
assertTrue(TaskInitiatorPermission.canOperate(task, "delegate"));
|
assertFalse(TaskInitiatorPermission.canOperate(task, "applicant"));
|
assertFalse(TaskInitiatorPermission.canOperate(task, null));
|
assertFalse(TaskInitiatorPermission.canOperate(task, " "));
|
assertFalse(TaskInitiatorPermission.canOperate(null, "owner"));
|
}
|
|
private FlowModel draft(int entry) {
|
FlowModel model = new FlowModel(); model.setFlowId("version"); model.setIsFlow(entry);
|
model.setStatus(0); model.setUserInfo(currentUser.get()); return model;
|
}
|
|
private static UserInfo user(String id) {
|
UserInfo user = new UserInfo(); user.setUserId(id); user.setUserName(id); return user;
|
}
|
|
private <T> T dependency(Class<T> type) {
|
return type.cast(dependencies.computeIfAbsent(type, key -> mock(type)));
|
}
|
|
private <T> T construct(Class<T> type) throws Exception {
|
Constructor<?> constructor = type.getConstructors()[0];
|
Object[] arguments = Arrays.stream(constructor.getParameterTypes()).map(this::dependency).toArray();
|
return type.cast(constructor.newInstance(arguments));
|
}
|
}
|
