package jnpf.base.service;
|
|
import jnpf.base.UserInfo;
|
import jnpf.base.mapper.UploadEditDraftMapper;
|
import jnpf.base.model.flow.DataModel;
|
import jnpf.base.model.uploadedit.UploadEditDraft;
|
import jnpf.exception.DataException;
|
import jnpf.util.UserProvider;
|
import org.junit.Before;
|
import org.junit.After;
|
import org.junit.Test;
|
import org.mockito.MockedStatic;
|
import java.util.*;
|
import static org.junit.Assert.*;
|
import static org.mockito.Mockito.*;
|
import static org.mockito.ArgumentMatchers.*;
|
|
public class UploadEditDraftServiceTest {
|
private UploadEditDraftMapper mapper;
|
private UploadEditDraftService service;
|
private UploadEditAccess access;
|
private UploadFilePermissionService permissions;
|
private UploadEditTemporaryService temporary;
|
private UploadEditDraft draft;
|
private DataModel model;
|
private MockedStatic<UserProvider> users;
|
@Before public void setup() {
|
jnpf.util.context.SpringContext.setApplicationContext(mock(org.springframework.context.ApplicationContext.class));
|
UserInfo user = new UserInfo(); user.setUserId("owner"); user.setTenantId("tenant");
|
users = mockStatic(UserProvider.class); users.when(UserProvider::getUser).thenReturn(user);
|
users.when(UserProvider::getLoginUserId).thenReturn("owner");
|
mapper = mock(UploadEditDraftMapper.class);
|
access = mock(UploadEditAccess.class);
|
when(access.hasEnabledFields("model")).thenReturn(true);
|
temporary = mock(UploadEditTemporaryService.class);
|
permissions = mock(UploadFilePermissionService.class);
|
service = new UploadEditDraftService(mapper, access, temporary, permissions);
|
draft = new UploadEditDraft(); draft.setId("draft"); draft.setModelId("model"); draft.setRecordId("record");
|
draft.setOwnerId("owner"); draft.setTenantId("tenant"); draft.setRevision(3L); draft.setField("files");
|
draft.setBaselineJson("[{\"fileId\":\"A\"}]"); draft.setCurrentJson("[{\"fileId\":\"B\"}]"); draft.setLeaseId("lease");
|
when(mapper.lockRecord("tenant", "model", "record")).thenReturn(Collections.singletonList(draft));
|
when(mapper.compareAndSet(any(), anyLong())).thenReturn(1);
|
model = new DataModel(); model.setVisualId("model"); model.setMainId("record"); model.setDataNewMap(new HashMap<>());
|
model.getDataNewMap().put("files", Collections.singletonList(Collections.singletonMap("fileId", "B")));
|
Map<String, Object> revision = new HashMap<>(); revision.put("draftId", "draft"); revision.put("revision", 3L);
|
model.getDataNewMap().put(UploadEditDraftService.SUBMIT_STATE, Collections.singletonList(revision));
|
}
|
@After public void teardown() { if (users != null) users.close(); }
|
@Test public void incompatibleDmsLoadDoesNotCreatePrivateDraft() {
|
when(access.isDmsAudit(any())).thenReturn(true);
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(), false));
|
assertIncompatible(() -> service.load(UploadEditDraftService.context(draft)));
|
verifyNoInteractions(mapper);
|
}
|
@Test public void incompatibleDmsSaveIsRejectedEvenWithoutAnyDraft() {
|
when(access.isDmsAudit(any())).thenReturn(true);
|
when(access.hasEnabledFields("model")).thenReturn(false);
|
assertIncompatible(() -> service.prepareSave(model, field -> false));
|
verifyNoInteractions(mapper);
|
}
|
@Test public void privateDmsDraftCannotBeMutatedThroughOldCommands() {
|
when(access.isDmsAudit(any())).thenReturn(true);
|
when(mapper.find("tenant", "draft")).thenReturn(draft);
|
var command = new jnpf.base.model.uploadedit.UploadEditCommand();
|
command.setDraftId("draft"); command.setRevision(3L);
|
assertIncompatible(() -> service.begin(command));
|
assertIncompatible(() -> service.replace(command));
|
assertIncompatible(() -> service.discard(command));
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void privateDmsLeaseCannotOpenOrSave() {
|
when(access.isDmsAudit(any())).thenReturn(true);
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
assertIncompatible(() -> service.lease("tenant", "owner", "lease"));
|
var command = new jnpf.base.model.uploadedit.UploadEditSaveCommand();
|
command.setTenantId("tenant"); command.setOwnerId("owner"); command.setLeaseId("lease");
|
assertIncompatible(() -> service.save(command));
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void privateDmsDraftCannotBeAdoptedEvenWithCurrentPermissions() {
|
var context = shared();
|
draft.setTaskId(null);
|
when(access.isDmsAudit(any())).thenReturn(true);
|
assertIncompatible(() -> service.prepareSave(model, field -> false, context));
|
assertEquals("[{\"fileId\":\"B\"}]", draft.getCurrentJson());
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
private static void assertIncompatible(Runnable action) {
|
try { action.run(); fail("incompatible DMS history must fail"); }
|
catch (DataException expected) { assertEquals(UploadEditAccess.DMS_INCOMPATIBLE, expected.getMessage()); }
|
}
|
@Test public void reviewPermissionCannotBeUpgradedByRequestedEditMode() {
|
org.springframework.data.redis.core.StringRedisTemplate redis = mock(org.springframework.data.redis.core.StringRedisTemplate.class);
|
service = new UploadEditDraftService(mapper, access, new UploadEditTemporaryService(access, mock(DmsAuditTemporaryEditService.class), redis), permissions);
|
shared(); draft.setLeaseId(null);
|
draft.setCurrentJson("[{\"fileId\":\"B\",\"name\":\"B.docx\"}]");
|
when(mapper.find("tenant", draft.getId())).thenReturn(draft);
|
when(access.baseline(any(), eq("owner"))).thenReturn(List.of(Map.of("fileId", "A")));
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "A")), true, "review"));
|
jnpf.base.model.uploadedit.UploadEditCommand command = new jnpf.base.model.uploadedit.UploadEditCommand();
|
command.setDraftId(draft.getId()); command.setRevision(3L); command.setFileId("B"); command.setMode("edit");
|
Map<String, Object> result = service.begin(command);
|
assertEquals("review", result.get("mode"));
|
assertTrue(draft.getLeaseId().startsWith("review_"));
|
when(mapper.findLease("tenant", draft.getLeaseId())).thenReturn(draft);
|
assertEquals("review", service.lease("tenant", "owner", draft.getLeaseId()).getMode());
|
assertTrue(service.canReadStatus("tenant", "owner", draft.getLeaseId()));
|
when(mapper.findLease("tenant", draft.getLeaseId())).thenReturn(null);
|
assertFalse(service.canReadStatus("tenant", "owner", draft.getLeaseId()));
|
try { service.lease("tenant", "owner", draft.getLeaseId()); fail("expired review lease"); }
|
catch (DataException expected) { assertEquals("编辑租约已失效", expected.getMessage()); }
|
verifyNoInteractions(redis);
|
}
|
@Test public void downgradedFullEditLeaseCannotOpenOrSave() {
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
draft.setLeaseFileId("B");
|
when(access.baseline(any(), eq("owner"))).thenReturn(List.of(Map.of("fileId", "A")));
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "A")), true, "review"));
|
try { service.lease("tenant", "owner", "lease"); fail("downgraded lease"); } catch (DataException expected) { }
|
jnpf.base.model.uploadedit.UploadEditSaveCommand command = new jnpf.base.model.uploadedit.UploadEditSaveCommand();
|
command.setTenantId("tenant"); command.setOwnerId("owner"); command.setLeaseId("lease");
|
try { service.save(command); fail("downgraded callback"); } catch (DataException expected) { }
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void loadedDraftReportsRestorePermissionInsteadOfOnlyContentDifference() {
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(Collections.singletonList(Collections.singletonMap("fileId", "A")), false));
|
when(mapper.find(anyString(), anyString())).thenReturn(draft);
|
when(permissions.canDiscardDraft(draft)).thenReturn(false, true);
|
assertEquals(false, service.load(UploadEditDraftService.context(draft)).get("canDiscard"));
|
assertEquals(true, service.load(UploadEditDraftService.context(draft)).get("canDiscard"));
|
assertTrue(draft.getCurrentJson().contains("B"));
|
}
|
@Test public void leaseRefreshesDownloadPermissionFromReleasedForm() {
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(Collections.singletonList(Collections.singletonMap("fileId", "A")), false));
|
draft.setLeaseFileId("B");
|
when(access.allowDownload(any())).thenReturn(true, false);
|
assertTrue(service.lease("tenant", "owner", "lease").isAllowDownload());
|
assertFalse(service.lease("tenant", "owner", "lease").isAllowDownload());
|
verify(access, times(2)).allowDownload(argThat(context -> "model".equals(context.getModelId()) && "files".equals(context.getField())));
|
}
|
@Test public void controlledLeaseStillChecksPermissionAndBaselineBeforeReturningFile() {
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
draft.setLeaseFileId("B"); draft.setTaskId("old-alias");
|
when(access.checkedBaseline(any(), eq("owner"))).thenAnswer(call -> {
|
jnpf.base.model.uploadedit.UploadEditContext context = call.getArgument(0);
|
context.setTaskId("actual-task");
|
return new UploadEditAccess.CheckedBaseline(Collections.singletonList(Collections.singletonMap("fileId", "A")), true);
|
});
|
assertEquals("B", service.lease("tenant", "owner", "lease").getFile().get("fileId"));
|
verify(access).checkedBaseline(any(), eq("owner"));
|
draft.setBaselineJson("[]");
|
try { service.lease("tenant", "owner", "lease"); fail("stale baseline"); } catch (DataException expected) { }
|
}
|
@Test public void statusChecksOnlyCurrentLeaseOwnershipWithoutLoadingForm() {
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
assertTrue(service.canReadStatus("tenant", "owner", "lease"));
|
assertFalse(service.canReadStatus("tenant", "another-owner", "lease"));
|
assertFalse(service.canReadStatus("other-tenant", "owner", "lease"));
|
verifyNoInteractions(access);
|
verify(temporary, never()).find(any(), any(), any());
|
}
|
@Test public void replacedOrAdoptedLeaseCannotReadStatus() {
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
assertTrue(service.canReadStatus("tenant", "owner", "lease"));
|
when(mapper.findLease("tenant", "lease")).thenReturn(null);
|
assertFalse(service.canReadStatus("tenant", "owner", "lease"));
|
verifyNoInteractions(access);
|
}
|
@Test public void temporaryStatusUsesOwnershipProbeRatherThanFileAuthorization() {
|
when(temporary.canReadStatus("tenant", "owner", "temporary")).thenReturn(true);
|
assertTrue(service.canReadStatus("tenant", "owner", "temporary"));
|
verifyNoInteractions(access);
|
verify(temporary, never()).find(any(), any(), any());
|
}
|
@Test public void statusAccessDoesNotBypassOpenOrSavePermissionChecks() {
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft);
|
when(access.baseline(any(), eq("owner"))).thenThrow(new DataException("权限已撤销"));
|
when(access.checkedBaseline(any(), eq("owner"))).thenThrow(new DataException("权限已撤销"));
|
assertTrue(service.canReadStatus("tenant", "owner", "lease"));
|
try { service.lease("tenant", "owner", "lease"); fail("opening must recheck permissions"); }
|
catch (DataException expected) { assertEquals("权限已撤销", expected.getMessage()); }
|
jnpf.base.model.uploadedit.UploadEditSaveCommand command = new jnpf.base.model.uploadedit.UploadEditSaveCommand();
|
command.setTenantId("tenant"); command.setOwnerId("owner"); command.setLeaseId("lease");
|
try { service.save(command); fail("saving must recheck permissions"); }
|
catch (DataException expected) { assertEquals("权限已撤销", expected.getMessage()); }
|
verify(access).baseline(any(), eq("owner"));
|
verify(access).checkedBaseline(any(), eq("owner"));
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void adoptsOnlyAfterNativeSaveAndStripsTransportMetadata() {
|
List<UploadEditDraft> prepared = service.prepareSave(model, field -> false);
|
assertFalse(model.getDataNewMap().containsKey(UploadEditDraftService.SUBMIT_STATE));
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
assertTrue(draft.getBaselineJson().contains("A"));
|
service.completeSave(prepared);
|
assertEquals(draft.getCurrentJson(), draft.getBaselineJson()); assertNull(draft.getLeaseId());
|
verify(mapper).compareAndSet(draft, 3L);
|
}
|
@Test(expected = DataException.class) public void missingVersionCannotSilentlyOverwriteDraft() {
|
model.getDataNewMap().remove(UploadEditDraftService.SUBMIT_STATE); service.prepareSave(model, field -> false);
|
}
|
@Test public void omittedFieldDoesNotAdoptDraft() {
|
model.getDataNewMap().remove("files"); assertTrue(service.prepareSave(model, field -> false).isEmpty());
|
}
|
@Test public void nativeDeniedFieldDoesNotAdvanceBaseline() {
|
assertTrue(service.prepareSave(model, field -> "files".equals(field)).isEmpty()); assertTrue(draft.getBaselineJson().contains("A"));
|
}
|
@Test public void deletingChildRowInvalidatesDraftOnSuccessfulAdoption() {
|
draft.setParentField("rows"); draft.setRowId("row"); model.getDataNewMap().put("rows", Collections.emptyList());
|
List<UploadEditDraft> prepared = service.prepareSave(model, field -> false); assertEquals(1, prepared.size());
|
service.completeSave(prepared); assertEquals("[]", draft.getBaselineJson()); assertNull(draft.getLeaseId());
|
}
|
@Test public void partialChildUpdateDoesNotDeleteMissingRowDraft() {
|
draft.setParentField("rows"); draft.setRowId("row"); model.getDataNewMap().put("rows", Collections.emptyList());
|
model.setOnlyUpdate(true); assertTrue(service.prepareSave(model, field -> false).isEmpty()); assertEquals("lease", draft.getLeaseId());
|
}
|
@Test public void controlledNativeSaveMaySupersedeOldDraftButDoesNotBecomeTrustedProof() {
|
model.getDataNewMap().remove(UploadEditDraftService.SUBMIT_STATE);
|
model.getDataNewMap().put("files", Collections.emptyList());
|
jnpf.flowable.model.filepermission.FilePermissionView view = new jnpf.flowable.model.filepermission.FilePermissionView();
|
UploadFilePermissionService.SaveContext permissions = new UploadFilePermissionService.SaveContext(Collections.emptyMap(), view);
|
List<UploadEditDraft> prepared = service.prepareSave(model, field -> false, permissions);
|
assertEquals(1, prepared.size()); assertTrue(permissions.nativeDraftIds.contains(draft.getId()));
|
assertEquals("[]", draft.getCurrentJson()); assertNull(draft.getEditOriginsJson());
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void controlledSaveStillRequiresVersionToAdoptAnExistingEditedDraft() {
|
model.getDataNewMap().remove(UploadEditDraftService.SUBMIT_STATE);
|
UploadFilePermissionService.SaveContext permissions = new UploadFilePermissionService.SaveContext(Collections.emptyMap(),
|
new jnpf.flowable.model.filepermission.FilePermissionView());
|
try { service.prepareSave(model, field -> false, permissions); fail("missing revision"); }
|
catch (DataException expected) { assertTrue(expected.getMessage().contains("版本缺失")); }
|
}
|
|
private UploadFilePermissionService.SaveContext shared() {
|
draft.setTaskId("task"); draft.setLeaseId(null);
|
draft.setId(jnpf.base.util.UploadEditWorkingCopy.id("tenant", UploadEditDraftService.context(draft)));
|
draft.setEditOriginsJson("{\"B\":\"A\"}");
|
model.getDataNewMap().put(UploadEditDraftService.SUBMIT_STATE,
|
Collections.singletonList(Map.of("draftId", draft.getId(), "revision", 3L)));
|
jnpf.flowable.model.filepermission.FilePermissionView view = jnpf.flowable.model.filepermission.FilePermissionView.legacy("task", "model");
|
view.setEnabled(true); view.setRevision("r1");
|
jnpf.flowable.model.filepermission.FilePermissionView.FieldAccess field = new jnpf.flowable.model.filepermission.FilePermissionView.FieldAccess();
|
field.setStatus("ready"); field.setActions(Map.of(jnpf.flowable.model.filepermission.FilePermissionPolicy.Action.VIEW, true));
|
view.setFields(Map.of("files", field));
|
return new UploadFilePermissionService.SaveContext(new HashMap<>(Map.of("files", List.of(Map.of("fileId", "A")))), view);
|
}
|
@Test public void viewerAdoptsAnotherEditorsPureChangeInReadonlyField() {
|
UploadFilePermissionService.SaveContext context = shared(); draft.setOwnerId("reviewer");
|
model.getDataNewMap().put("files", List.of(Map.of("fileId", "forged")));
|
assertEquals(1, service.prepareSave(model, field -> true, context).size());
|
assertTrue(model.getWorkflowWorkingFields().contains("files"));
|
assertEquals("B", ((Map<?, ?>)((List<?>)model.getDataNewMap().get("files")).get(0)).get("fileId"));
|
assertTrue(context.sharedDraftIds.contains(draft.getId()));
|
assertTrue(draft.getBaselineJson().contains("A"));
|
service.completeSave(List.of(draft));
|
assertTrue(draft.getBaselineJson().contains("B"));
|
}
|
@Test public void readonlyAdoptionRejectsUploadReplacementDisguisedAsEdit() {
|
UploadFilePermissionService.SaveContext context = shared(); draft.setEditOriginsJson(null);
|
try { service.prepareSave(model, field -> true, context); fail("replacement"); } catch (DataException expected) { }
|
assertTrue(model.getWorkflowWorkingFields().isEmpty());
|
}
|
@Test public void sharedAdoptionRejectsStaleRevisionAndActiveLease() {
|
UploadFilePermissionService.SaveContext context = shared(); draft.setRevision(4L);
|
try { service.prepareSave(model, field -> true, context); fail("stale"); } catch (DataException expected) { }
|
context = shared(); draft.setLeaseId("active"); draft.setUpdatedAt(new Date());
|
try { service.prepareSave(model, field -> true, context); fail("active lease"); } catch (DataException expected) { }
|
}
|
@Test public void sharedAdoptionRequiresVersionExceptForServerNodeCheckpoint() {
|
UploadFilePermissionService.SaveContext context = shared(); model.getDataNewMap().remove(UploadEditDraftService.SUBMIT_STATE);
|
try { service.prepareSave(model, field -> true, context); fail("missing version"); } catch (DataException expected) { }
|
model.setWorkflowFileCheckpoint(true);
|
assertEquals(1, service.prepareSave(model, field -> true, context).size());
|
}
|
@Test public void sharedReadDoesNotRequireEditorOwnership() {
|
shared(); draft.setOwnerId("reviewer");
|
when(access.sharedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "A")), true));
|
when(mapper.find("tenant", draft.getId())).thenReturn(draft);
|
assertEquals(true, service.loadShared(UploadEditDraftService.context(draft)).get("shared"));
|
verify(access, never()).checkedBaseline(any(), anyString());
|
}
|
@Test public void sharedLeaseCannotBeTakenOverUntilClosedOrExpired() {
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "A")), true));
|
shared(); draft.setCurrentJson("[{\"fileId\":\"B\",\"name\":\"B.docx\"}]");
|
draft.setOwnerId("reviewer"); draft.setLeaseId("active"); draft.setUpdatedAt(new Date());
|
when(mapper.find("tenant", draft.getId())).thenReturn(draft);
|
when(access.baseline(any(), eq("owner"))).thenReturn(List.of(Map.of("fileId", "A")));
|
jnpf.base.model.uploadedit.UploadEditCommand command = new jnpf.base.model.uploadedit.UploadEditCommand();
|
command.setDraftId(draft.getId()); command.setRevision(3L); command.setFileId("B");
|
try { service.begin(command); fail("active lease"); } catch (DataException expected) { }
|
draft.setUpdatedAt(new Date(System.currentTimeMillis() - 121_000));
|
service.begin(command); assertEquals("owner", draft.getOwnerId()); assertFalse("active".equals(draft.getLeaseId()));
|
command.setFileId(draft.getLeaseId()); service.close(command); assertNull(draft.getLeaseId());
|
}
|
@Test public void expiredLeaseCannotSaveOrRenewAndForeignUserCannotClose() {
|
shared(); draft.setLeaseId("active"); draft.setUpdatedAt(new Date(System.currentTimeMillis() - 121_000));
|
when(mapper.find("tenant", draft.getId())).thenReturn(draft); when(mapper.findLease("tenant", "active")).thenReturn(draft);
|
jnpf.base.model.uploadedit.UploadEditCommand command = new jnpf.base.model.uploadedit.UploadEditCommand();
|
command.setDraftId(draft.getId()); command.setFileId("active");
|
try { service.heartbeat(command); fail("expired"); } catch (DataException expected) { }
|
try { service.lease("tenant", "owner", "active"); fail("expired"); } catch (DataException expected) { }
|
draft.setOwnerId("other");
|
try { service.close(command); fail("foreign"); } catch (DataException expected) { }
|
verify(mapper, never()).touchLease(any(), any(), any(), any(), any(), any());
|
}
|
|
@Test public void sharedChildAdoptionUsesEachRowsServerValueWithoutGrantingOtherRowWrites() {
|
UploadFilePermissionService.SaveContext initial = shared();
|
draft.setParentField("rows"); draft.setRowId("one"); draft.setId(jnpf.base.util.UploadEditWorkingCopy.id("tenant", UploadEditDraftService.context(draft)));
|
UploadEditDraft second = new UploadEditDraft(); second.setTenantId("tenant"); second.setTaskId("task"); second.setModelId("model"); second.setRecordId("record");
|
second.setParentField("rows"); second.setRowId("two"); second.setField("files"); second.setOwnerId("reviewer"); second.setRevision(3L);
|
second.setBaselineJson("[{\"fileId\":\"C\"}]"); second.setCurrentJson("[{\"fileId\":\"D\"}]"); second.setEditOriginsJson("{\"D\":\"C\"}");
|
second.setId(jnpf.base.util.UploadEditWorkingCopy.id("tenant",UploadEditDraftService.context(second)));
|
when(mapper.lockRecord("tenant","model","record")).thenReturn(List.of(draft,second));
|
initial.permissions.setFields(Map.of("rows-files",initial.permissions.getFields().get("files")));
|
Map<String,Object> one = new HashMap<>(Map.of("id","one","files",List.of(Map.of("fileId","A")),"note","keep"));
|
Map<String,Object> two = new HashMap<>(Map.of("id","two","files",List.of(Map.of("fileId","C"))));
|
Map<String,Object> baseline = Map.of("rows", List.of(new HashMap<>(one),new HashMap<>(two)));
|
model.getDataNewMap().put("rows",List.of(one,two));
|
model.getDataNewMap().put(UploadEditDraftService.SUBMIT_STATE,List.of(Map.of("draftId",draft.getId(),"revision",3L),Map.of("draftId",second.getId(),"revision",3L)));
|
assertEquals(2,service.prepareSave(model,key -> !model.getWorkflowWorkingFields().contains(key),new UploadFilePermissionService.SaveContext(baseline,initial.permissions)).size());
|
assertEquals(List.of(Map.of("fileId","B")),one.get("files")); assertEquals(List.of(Map.of("fileId","D")),two.get("files"));
|
assertEquals("keep",one.get("note"));
|
assertEquals(1,model.getWorkflowWorkingFields().size());
|
}
|
|
@Test public void nativeMainSaveKeepsPersistedSourceButClearsOrdinaryReplacement() {
|
when(access.isDmsAuditTemporary(any())).thenReturn(true);
|
when(mapper.lockRecord("tenant", "model", "record")).thenReturn(List.of());
|
when(permissions.dmsMainAttachmentBaseline(model)).thenReturn(List.of(Map.of("fileId", "A", "laiyuan_muban_id", "templateA")));
|
model.getDataNewMap().put("wenjian", "[{\"fileId\":\"A\",\"laiyuan_muban_id\":\"forged\"}]");
|
service.prepareSave(model, field -> false);
|
assertTrue(model.getDataNewMap().get("wenjian").toString().contains("templateA"));
|
when(access.hasEnabledFields("model")).thenReturn(false);
|
service.prepareSave(model, field -> false);
|
assertTrue(model.getDataNewMap().get("wenjian").toString().contains("templateA"));
|
model.getDataNewMap().put("wenjian", List.of(Map.of("fileId", "new", "laiyuan_muban_id", "templateA")));
|
service.prepareSave(model, field -> false);
|
assertFalse(((Map<?,?>)((List<?>)model.getDataNewMap().get("wenjian")).get(0)).containsKey("laiyuan_muban_id"));
|
}
|
@Test public void nativeMainSaveAcceptsNewTemplateForSameFileId() {
|
when(access.isDmsAuditTemporary(any())).thenReturn(true);
|
when(mapper.lockRecord("tenant", "model", "record")).thenReturn(List.of());
|
when(permissions.dmsMainAttachmentBaseline(model)).thenReturn(List.of(Map.of("fileId", "A", "laiyuan_muban_id", "templateA")));
|
try(var tickets=mockStatic(jnpf.util.TicketUtil.class)) {
|
tickets.when(() -> jnpf.util.TicketUtil.parseTicket("new")).thenReturn(jnpf.util.JsonUtil.getObjectToString(Map.of(
|
"purpose", "upload-edit-source", "tenantId", "tenant", "ownerId", "owner", "fileId", "A", "laiyuan_muban_id", "templateB")));
|
model.getDataNewMap().put("wenjian", List.of(Map.of("fileId", "A", "uploadReceipt", "new")));
|
service.prepareSave(model, field -> false);
|
assertEquals("templateB", ((Map<?,?>)((List<?>)model.getDataNewMap().get("wenjian")).get(0)).get("laiyuan_muban_id"));
|
}
|
}
|
|
|
@Test public void dmsLoadWithoutDraftIsReadOnlyAndReturnsContentIdentity() {
|
shared();
|
when(access.sharedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "A")), true, "edit", true));
|
Map<String,Object> view = service.loadShared(UploadEditDraftService.context(draft));
|
assertEquals(true, view.get("dmsAudit"));
|
verify(access, never()).isDmsAudit(any());
|
assertEquals(jnpf.base.util.UploadEditStateMachine.contentToken(draft.getBaselineJson()), view.get("contentToken"));
|
verify(mapper, never()).insert(any()); verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void dmsStaleLoadDoesNotResetSavedDraft() {
|
shared();
|
when(mapper.find(anyString(), anyString())).thenReturn(draft);
|
when(access.sharedBaseline(any(), eq("owner"))).thenReturn(new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "C")), true, "edit", true));
|
Map<String,Object> view = service.loadShared(UploadEditDraftService.context(draft));
|
assertEquals(true, view.get("dmsAudit"));
|
verify(access, never()).isDmsAudit(any());
|
assertEquals(List.of(Map.of("fileId", "C")), view.get("files"));
|
assertTrue(draft.getCurrentJson().contains("B"));
|
verify(mapper, never()).insert(any()); verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
@Test public void dmsContentConfirmationSurvivesLeaseRevisionButRejectsChangedContent() {
|
UploadFilePermissionService.SaveContext context = shared(); when(access.isDmsAudit(any())).thenReturn(true);
|
String token = jnpf.base.util.UploadEditStateMachine.contentToken(draft.getCurrentJson());
|
model.getDataNewMap().put(UploadEditDraftService.SUBMIT_STATE, List.of(Map.of("draftId", draft.getId(), "revision", 1L, "contentToken", token)));
|
assertEquals(1, service.prepareSave(model, field -> true, context).size());
|
model.getDataNewMap().put(UploadEditDraftService.SUBMIT_STATE, List.of(Map.of("draftId", draft.getId(), "revision", 3L, "contentToken", "old")));
|
try { service.prepareSave(model, field -> true, context); fail("changed content"); }
|
catch (DataException expected) { assertTrue(expected.getMessage().contains("重新预览")); }
|
}
|
@Test public void dmsCheckpointCannotAdoptUnconfirmedSavedContent() {
|
UploadFilePermissionService.SaveContext context = shared(); when(access.isDmsAudit(any())).thenReturn(true);
|
model.setWorkflowFileCheckpoint(true); model.getDataNewMap().remove(UploadEditDraftService.SUBMIT_STATE);
|
try { service.prepareSave(model, field -> true, context); fail("unconfirmed"); }
|
catch (DataException expected) { assertTrue(expected.getMessage().contains("尚未确认")); }
|
}
|
@Test public void dmsBeginLocksExistingParentBeforeCreatingFirstDraftAndCloseKeepsContent() {
|
shared(); when(access.isDmsAudit(any())).thenReturn(true);
|
when(access.dmsAuditTable("model")).thenReturn("dms_wenjian_xiuding_shenhe");
|
when(mapper.lockDmsRecord("tenant", "dms_wenjian_xiuding_shenhe", "record")).thenReturn("record");
|
var baseline = new UploadEditAccess.CheckedBaseline(List.of(Map.of("fileId", "A", "name", "A.docx")), true, "edit", true);
|
when(access.sharedBaseline(any(), eq("owner"))).thenReturn(baseline);
|
when(access.checkedBaseline(any(), eq("owner"))).thenReturn(baseline);
|
when(access.baseline(any(), eq("owner"))).thenReturn(baseline.getFiles());
|
java.util.concurrent.atomic.AtomicReference<UploadEditDraft> stored = new java.util.concurrent.atomic.AtomicReference<>();
|
when(mapper.find(anyString(), anyString())).thenAnswer(call -> stored.get());
|
when(mapper.insert(any())).thenAnswer(call -> { stored.set(call.getArgument(0)); return 1; });
|
var command = new jnpf.base.model.uploadedit.UploadEditCommand();
|
command.setContext(UploadEditDraftService.context(draft)); command.setDraftId(draft.getId()); command.setFileId("A");
|
command.setContentToken(jnpf.base.util.UploadEditStateMachine.contentToken(baseline.getFiles()));
|
var lease = service.begin(command);
|
var order = inOrder(mapper); order.verify(mapper).lockDmsRecord("tenant", "dms_wenjian_xiuding_shenhe", "record");
|
order.verify(mapper).insert(any());
|
try { service.begin(command); fail("concurrent lease"); } catch (DataException expected) { assertTrue(expected.getMessage().contains("正在编辑")); }
|
var close = new jnpf.base.model.uploadedit.UploadEditCommand(); close.setDraftId(draft.getId()); close.setFileId((String)lease.get("leaseId"));
|
service.close(close);
|
assertEquals(lease.get("contentToken"), service.loadShared(command.getContext()).get("contentToken"));
|
}
|
@Test public void dmsMetadataChangesAreRejectedEvenWhenContentTokenMatches() {
|
var context = shared(); when(access.isDmsAudit(any())).thenReturn(true);
|
model.getDataNewMap().put(UploadEditDraftService.SUBMIT_STATE, List.of(Map.of("draftId", draft.getId(), "revision", 3L,
|
"contentToken", jnpf.base.util.UploadEditStateMachine.contentToken(draft.getCurrentJson()), "metadataToken", "stale")));
|
try { service.prepareSave(model, f -> false, context); fail("metadata conflict must reject"); }
|
catch (DataException expected) { assertTrue(expected.getMessage().contains("模板来源")); }
|
}
|
@Test public void callbackRechecksLeaseAfterAcquiringNativeParentLock() {
|
shared(); draft.setLeaseId("lease"); draft.setUpdatedAt(new Date());
|
when(access.isDmsAudit(any())).thenReturn(true);
|
when(access.dmsAuditTable("model")).thenReturn("dms_wenjian_xinzeng_shenhe");
|
when(mapper.lockDmsRecord("tenant", "dms_wenjian_xinzeng_shenhe", "record")).thenReturn("record");
|
when(mapper.findLease("tenant", "lease")).thenReturn(draft, null);
|
var command = new jnpf.base.model.uploadedit.UploadEditSaveCommand();
|
command.setTenantId("tenant"); command.setOwnerId("owner"); command.setLeaseId("lease");
|
assertFalse(service.save(command));
|
var order = inOrder(mapper);
|
order.verify(mapper).findLease("tenant", "lease");
|
order.verify(mapper).lockDmsRecord("tenant", "dms_wenjian_xinzeng_shenhe", "record");
|
order.verify(mapper).findLease("tenant", "lease");
|
verify(mapper, never()).compareAndSet(any(), anyLong());
|
}
|
}
|
