package jnpf.base.service;
|
|
import jnpf.base.UserInfo;
|
import jnpf.base.entity.VisualdevEntity;
|
import jnpf.base.model.flow.DataModel;
|
import jnpf.base.model.uploadedit.UploadEditDraft;
|
import jnpf.base.util.FlowFormDataUtil;
|
import jnpf.exception.DataException;
|
import jnpf.flowable.WorkFlowApi;
|
import jnpf.flowable.model.filepermission.FilePermissionPolicy.Action;
|
import jnpf.flowable.model.filepermission.FilePermissionView;
|
import jnpf.model.visualjson.FieLdsModel;
|
import jnpf.model.visualjson.TableModel;
|
import jnpf.model.visualjson.analysis.*;
|
import jnpf.util.JsonUtil;
|
import jnpf.util.TicketUtil;
|
import jnpf.util.UserProvider;
|
import org.junit.*;
|
import org.mockito.MockedStatic;
|
import org.springframework.beans.factory.ObjectProvider;
|
import java.util.*;
|
import static org.junit.Assert.*;
|
import static org.mockito.Mockito.*;
|
|
public class UploadFilePermissionServiceTest {
|
private UploadFilePermissionService service;
|
private DataModel model;
|
private Map<String, Object> baseline;
|
private FilePermissionView permissions;
|
private UploadFilePermissionService.SaveContext context;
|
private MockedStatic<UserProvider> users;
|
private FlowFormDataUtil forms;
|
private WorkFlowApi workflow;
|
private VisualdevService models;
|
|
@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);
|
ObjectProvider<VisualdevService> modelProvider = mock(ObjectProvider.class);
|
ObjectProvider<FlowFormDataUtil> formProvider = mock(ObjectProvider.class);
|
models = mock(VisualdevService.class); forms = mock(FlowFormDataUtil.class); workflow = mock(WorkFlowApi.class);
|
when(modelProvider.getObject()).thenReturn(models); when(formProvider.getObject()).thenReturn(forms);
|
service = new UploadFilePermissionService(modelProvider, formProvider, new UploadFilePermissionQuery(workflow, mock(ObjectProvider.class)));
|
model = new DataModel(); model.setVisualId("model"); model.setMainId("record");
|
model.setDataNewMap(new HashMap<>()); model.setTableModelList(new ArrayList<>());
|
FormAllModel field = new FormAllModel(); FormColumnModel column = new FormColumnModel();
|
column.setFieLdsModel(field()); field.setFormColumnModel(column);
|
model.setFormAllModel(Collections.singletonList(field));
|
baseline = new HashMap<>(); baseline.put("id", "record"); baseline.put("files", files("A")); baseline.put("flowTaskId", "actual-task");
|
model.getDataNewMap().put("files", files("A"));
|
permissions = new FilePermissionView(); permissions.setTaskId("actual-task"); permissions.setFormId("model");
|
permissions.setStatus("ready"); permissions.setRevision("revision");
|
allow("files");
|
context = new UploadFilePermissionService.SaveContext(baseline, permissions);
|
}
|
@Test public void persistedMenuDraftWithoutTaskUsesNativeSaveButMissingTaskInRunningRecordFails() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
when(forms.getFilePermissionDataInfo(eq(released), eq("record"), any())).thenReturn(baseline);
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(FilePermissionView.unavailable("actual-task", "model", "TASK_NOT_FOUND"));
|
Map<String,Object> state = new HashMap<>(); state.put("flowId", "flow"); state.put("flowState", 0); state.put("deleteMark", null);
|
baseline.put(FilePermissionNativeDraft.STATE_KEY, state);
|
assertNull(service.prepare(model));
|
state.put("flowState", 1);
|
model.getDataNewMap().put("flowState", 0); model.getDataNewMap().put("isNew", true);
|
denied("权限暂不可用", () -> service.prepare(model));
|
state.put("flowState", 0); state.put("deleteMark", 1);
|
denied("权限暂不可用", () -> service.prepare(model));
|
state.put("deleteMark", null);
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(FilePermissionView.unavailable("actual-task", "model", "PERMISSION_UNAVAILABLE"));
|
denied("权限暂不可用", () -> service.prepare(model));
|
}
|
@After public void cleanup() { users.close(); }
|
private FieLdsModel field() {
|
return JsonUtil.getJsonToBean("{\"__vModel__\":\"files\",\"__config__\":{\"jnpfKey\":\"uploadFile\"}}", FieLdsModel.class);
|
}
|
private List<Map<String, Object>> files(String... ids) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (String id : ids) { Map<String, Object> f = new HashMap<>(); f.put("fileId", id); result.add(f); }
|
return result;
|
}
|
private void allow(String field, Action... actions) {
|
FilePermissionView.FieldAccess access = new FilePermissionView.FieldAccess(); access.setStatus("ready");
|
Map<Action, Boolean> values = new EnumMap<>(Action.class); for (Action action : actions) values.put(action, true);
|
access.setActions(values); permissions.getFields().put(field, access);
|
}
|
private void validate(UploadEditDraft... drafts) { service.validate(context, model, Arrays.asList(drafts), f -> false); }
|
private void denied(String message, Runnable call) {
|
try { call.run(); fail("expected rejection: " + message); }
|
catch (DataException expected) { assertTrue(expected.getMessage(), expected.getMessage().contains(message)); }
|
}
|
private UploadEditDraft draft(String origin, String result) {
|
UploadEditDraft d = new UploadEditDraft(); d.setId("draft"); d.setOwnerId("owner"); d.setRecordId("record");
|
d.setModelId("model"); d.setField("files"); d.setBaselineJson(JsonUtil.getObjectToString(files("A")));
|
d.setCurrentJson(JsonUtil.getObjectToString(files(result)));
|
d.setEditOriginsJson(JsonUtil.getObjectToString(Collections.singletonMap(result, origin))); return d;
|
}
|
private void children() {
|
FormAllModel item = new FormAllModel(); FormColumnTableModel child = new FormColumnTableModel();
|
child.setTableModel("rows"); child.setTableName("child_table");
|
FormColumnModel column = new FormColumnModel(); column.setFieLdsModel(field());
|
child.setChildList(Collections.singletonList(column)); item.setChildList(child);
|
model.setFormAllModel(Collections.singletonList(item));
|
TableModel table = new TableModel(); table.setTable("child_table"); model.setTableModelList(Collections.singletonList(table));
|
when(forms.getKey(eq(table), any())).thenReturn("custom_id");
|
Map<String, Object> row = new HashMap<>(); row.put("custom_id", "row-1"); row.put("files", files("A"));
|
baseline.put("rows", Collections.singletonList(row));
|
model.getDataNewMap().put("rows", new ArrayList<>(Collections.singletonList(new HashMap<>(row))));
|
allow("rows-files");
|
}
|
@Test public void usesRealRecordTaskAndPreservesLegacy() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
when(forms.getFilePermissionDataInfo(eq(released), eq("record"), any())).thenReturn(baseline);
|
model.getDataNewMap().put("flowTaskId", "forged-task");
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(FilePermissionView.legacy("actual-task", "model"));
|
assertNull(service.prepare(model)); verify(workflow).filePermissions("actual-task", "model");
|
}
|
@Test public void mismatchedPermissionResponseFailsClosed() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
when(forms.getFilePermissionDataInfo(eq(released), anyString(), any())).thenReturn(baseline);
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(FilePermissionView.legacy("other-task", "model"));
|
denied("权限暂不可用", () -> service.prepare(model));
|
}
|
@Test public void savedEmptyBaselineStillRequiresAddPermission() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
baseline.put("files", Collections.emptyList());
|
when(forms.getFilePermissionDataInfo(eq(released), eq("record"), any())).thenReturn(baseline);
|
permissions.setEnabled(true);
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(permissions);
|
model.getDataNewMap().put("flowTaskId", "");
|
model.getDataNewMap().put("id", "");
|
model.getDataNewMap().put("isNew", true);
|
context = service.prepare(model);
|
assertNotNull(context);
|
Map<String, Object> uploaded = files("A").get(0); uploaded.put("uploadReceipt", "receipt");
|
model.getDataNewMap().put("files", Collections.singletonList(uploaded));
|
try (MockedStatic<TicketUtil> tickets = mockStatic(TicketUtil.class)) {
|
tickets.when(() -> TicketUtil.parseTicket("receipt")).thenReturn(
|
"{\"purpose\":\"upload-edit-source\",\"tenantId\":\"tenant\",\"ownerId\":\"owner\",\"fileId\":\"A\"}");
|
denied("ADD", () -> validate());
|
}
|
}
|
@Test public void missingSavedBaselineCannotFallBackToInitialCreate() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
when(forms.getFilePermissionDataInfo(eq(released), eq("record"), any())).thenReturn(Collections.emptyMap());
|
denied("记录不存在", () -> service.prepare(model));
|
verifyNoInteractions(workflow);
|
}
|
@Test public void unchangedFilesNeedNoMutationPermissionAndCannotForgeUrl() {
|
Map<String, Object> forged = files("A").get(0); forged.put("url", "other-file");
|
model.getDataNewMap().put("files", Collections.singletonList(forged)); validate();
|
assertEquals(files("A"), model.getDataNewMap().get("files"));
|
}
|
@Test public void omittedMainColumnIsRemovalNotPatch() {
|
model.getDataNewMap().remove("files"); denied("REMOVE", () -> validate());
|
}
|
@Test public void wrongCaseMainColumnCannotHideNativeNullWrite() {
|
model.getDataNewMap().remove("files"); model.getDataNewMap().put("FILES", files("A")); denied("REMOVE", () -> validate());
|
}
|
@Test public void ignoredNativeColumnDoesNotRequireActions() {
|
model.getDataNewMap().remove("files"); service.validate(context, model, Collections.emptyList(), f -> true);
|
}
|
@Test public void wholeChildRowDeletionRequiresRemoveEvenWhenColumnIsReadOnly() {
|
children(); model.getDataNewMap().put("rows", Collections.emptyList());
|
denied("REMOVE", () -> service.validate(context, model, Collections.emptyList(), f -> true));
|
}
|
@Test public void omittedChildTableAlsoRequiresRemove() {
|
children(); model.getDataNewMap().remove("rows"); denied("REMOVE", () -> validate());
|
}
|
@Test public void onlyUpdatePreservesMissingRows() {
|
children(); model.setOnlyUpdate(true); model.getDataNewMap().remove("rows"); validate();
|
}
|
@Test public void omittedChildFileColumnRequiresRemove() {
|
children(); Map<String, Object> row = new HashMap<>(); row.put("CUSTOM_ID", "row-1");
|
model.getDataNewMap().put("rows", Collections.singletonList(row)); denied("REMOVE", () -> validate());
|
}
|
@Test public void disabledChildTableIsNotMutatedByNativeSave() {
|
children(); model.getFormAllModel().get(0).getChildList().setDisabled(true);
|
model.getDataNewMap().remove("rows"); validate();
|
}
|
@Test public void trustedEditIsEditInsteadOfReplacement() {
|
allow("files", Action.EDIT, Action.VIEW); model.getDataNewMap().put("files", files("B")); validate(draft("A", "B"));
|
}
|
@Test public void revokedEditCannotBeAdoptedUsingReplacePermission() {
|
allow("files", Action.REPLACE); model.getDataNewMap().put("files", files("B"));
|
denied("EDIT", () -> validate(draft("A", "B")));
|
}
|
@Test public void uploadedThenEditedFileStillRequiresReplacement() {
|
allow("files", Action.EDIT, Action.VIEW); model.getDataNewMap().put("files", files("D"));
|
denied("REPLACE", () -> validate(draft("C", "D")));
|
allow("files", Action.EDIT, Action.VIEW, Action.REPLACE); validate(draft("C", "D"));
|
}
|
@Test public void otherRowOrOwnerDraftIsNotProof() {
|
allow("files", Action.EDIT, Action.REPLACE); model.getDataNewMap().put("files", files("B"));
|
UploadEditDraft other = draft("A", "B"); other.setOwnerId("other");
|
denied("上传来源", () -> validate(other));
|
}
|
@Test public void nativeOverrideCannotUseOldDraftAsUploadProof() {
|
allow("files", Action.REPLACE); model.getDataNewMap().put("files", files("B"));
|
context.nativeDraftIds.add("draft"); denied("上传来源", () -> validate(draft("A", "B")));
|
}
|
@Test public void verifiedUploadMayReplaceAndCannotForgeSourceMetadata() {
|
allow("files", Action.REPLACE);
|
Map<String, Object> uploaded = files("C").get(0); uploaded.put("uploadReceipt", "receipt"); uploaded.put("url", "forged");
|
model.getDataNewMap().put("files", Collections.singletonList(uploaded));
|
Map<String, Object> proof = new HashMap<>(); proof.put("purpose", "upload-edit-source"); proof.put("tenantId", "tenant");
|
proof.put("ownerId", "owner"); proof.put("fileId", "C"); proof.put("url", "actual");
|
try (MockedStatic<TicketUtil> tickets = mockStatic(TicketUtil.class)) {
|
tickets.when(() -> TicketUtil.parseTicket("receipt")).thenReturn(JsonUtil.getObjectToString(proof));
|
validate();
|
}
|
List<?> accepted = (List<?>) model.getDataNewMap().get("files"); assertEquals("actual", ((Map<?, ?>) accepted.get(0)).get("url"));
|
}
|
@Test public void anotherTenantsUploadReceiptCannotBeUsed() {
|
allow("files", Action.REPLACE);
|
Map<String, Object> uploaded = files("C").get(0); uploaded.put("uploadReceipt", "receipt");
|
model.getDataNewMap().put("files", Collections.singletonList(uploaded));
|
try (MockedStatic<TicketUtil> tickets = mockStatic(TicketUtil.class)) {
|
tickets.when(() -> TicketUtil.parseTicket("receipt")).thenReturn("{\"purpose\":\"upload-edit-source\",\"tenantId\":\"other\",\"ownerId\":\"owner\",\"fileId\":\"C\"}");
|
denied("上传来源", () -> validate());
|
}
|
}
|
private void currentDraftContext() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
when(forms.getFilePermissionDataInfo(eq(released), eq("record"), any())).thenReturn(baseline);
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(permissions);
|
}
|
private Map<String, Object> nativeDraftContext() {
|
currentDraftContext();
|
when(workflow.filePermissions("actual-task", "model"))
|
.thenReturn(FilePermissionView.unavailable("actual-task", "model", "TASK_NOT_FOUND"));
|
Map<String, Object> state = new HashMap<>();
|
state.put("flowId", "flow"); state.put("flowState", 0); state.put("deleteMark", null);
|
baseline.put(FilePermissionNativeDraft.STATE_KEY, state);
|
return state;
|
}
|
@Test public void nativeMenuDraftCanDiscardEditedMainAndChildAttachments() {
|
nativeDraftContext();
|
UploadEditDraft main = draft("A", "B");
|
assertTrue(service.canDiscardDraft(main));
|
service.validateDraftDiscard(main);
|
UploadEditDraft child = draft("A", "C"); child.setParentField("rows"); child.setRowId("row-1");
|
assertTrue(service.canDiscardDraft(child));
|
service.validateDraftDiscard(child);
|
assertFalse(service.canDiscardDraft(draft("A", "A")));
|
service.validateDraftChange(main, files("D"));
|
}
|
@Test public void missingTaskDoesNotAllowDiscardOfRunningDeletedOrUnverifiedRecord() {
|
Map<String, Object> state = nativeDraftContext();
|
UploadEditDraft edited = draft("A", "B");
|
state.put("flowState", 1);
|
assertFalse(service.canDiscardDraft(edited));
|
denied("权限暂不可用", () -> service.validateDraftDiscard(edited));
|
denied("权限暂不可用", () -> service.validateDraftChange(edited, files("D")));
|
state.put("flowState", 0); state.put("deleteMark", 1);
|
assertFalse(service.canDiscardDraft(edited));
|
denied("权限暂不可用", () -> service.validateDraftDiscard(edited));
|
state.put("deleteMark", null); baseline.put("id", "other-record");
|
assertFalse(service.canDiscardDraft(edited));
|
baseline.put("id", "record"); baseline.remove(FilePermissionNativeDraft.STATE_KEY);
|
assertFalse(service.canDiscardDraft(edited));
|
}
|
@Test public void nativeDraftDiscardDoesNotDowngradePermissionErrorsOrMismatchedResponses() {
|
nativeDraftContext();
|
UploadEditDraft edited = draft("A", "B");
|
when(workflow.filePermissions("actual-task", "model"))
|
.thenReturn(FilePermissionView.unavailable("actual-task", "model", "PERMISSION_UNAVAILABLE"));
|
assertFalse(service.canDiscardDraft(edited));
|
denied("权限暂不可用", () -> service.validateDraftDiscard(edited));
|
when(workflow.filePermissions("actual-task", "model"))
|
.thenReturn(FilePermissionView.unavailable("other-task", "model", "TASK_NOT_FOUND"));
|
assertFalse(service.canDiscardDraft(edited));
|
when(workflow.filePermissions("actual-task", "model")).thenThrow(new IllegalStateException("offline"));
|
assertFalse(service.canDiscardDraft(edited));
|
}
|
@Test public void nativeDraftDiscardUsesInstanceRulesOnceTaskExists() {
|
nativeDraftContext();
|
UploadEditDraft edited = draft("A", "B");
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(permissions);
|
assertFalse(service.canDiscardDraft(edited));
|
denied("EDIT", () -> service.validateDraftDiscard(edited));
|
allow("files", Action.EDIT);
|
assertTrue(service.canDiscardDraft(edited));
|
service.validateDraftDiscard(edited);
|
}
|
@Test public void discardDecisionUsesActualChangeAndCurrentPermissions() {
|
currentDraftContext(); allow("files", Action.EDIT);
|
UploadEditDraft edited = draft("A", "B");
|
assertTrue(service.canDiscardDraft(edited));
|
allow("files", Action.REPLACE);
|
assertFalse(service.canDiscardDraft(edited));
|
UploadEditDraft replacement = draft("C", "C");
|
assertTrue(service.canDiscardDraft(replacement));
|
replacement.setCurrentJson("[]");
|
assertFalse(service.canDiscardDraft(replacement));
|
allow("files", Action.ADD);
|
assertTrue(service.canDiscardDraft(replacement));
|
}
|
@Test public void discardDecisionIsFalseForUnchangedOrUnavailableDraft() {
|
UploadEditDraft unchanged = draft("A", "A");
|
assertFalse(service.canDiscardDraft(unchanged));
|
verifyNoInteractions(workflow);
|
currentDraftContext();
|
when(workflow.filePermissions("actual-task", "model")).thenThrow(new IllegalStateException("offline"));
|
assertFalse(service.canDiscardDraft(draft("A", "B")));
|
}
|
@Test public void discardDecisionKeepsLegacyButRejectsMissingEditProvenance() {
|
currentDraftContext();
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(FilePermissionView.legacy("actual-task", "model"));
|
assertTrue(service.canDiscardDraft(draft("A", "B")));
|
when(workflow.filePermissions("actual-task", "model")).thenReturn(permissions);
|
allow("files", Action.REPLACE);
|
UploadEditDraft old = draft("A", "onlyoffice-edit-temp,tenant,lease,result.docx");
|
old.setEditOriginsJson(null);
|
assertFalse(service.canDiscardDraft(old));
|
}
|
@Test public void discardDecisionUsesChildFieldPermissionsIndependently() {
|
currentDraftContext(); allow("files", Action.EDIT); allow("rows-files");
|
UploadEditDraft child = draft("A", "B"); child.setParentField("rows"); child.setRowId("row-1");
|
assertFalse(service.canDiscardDraft(child));
|
allow("rows-files", Action.EDIT);
|
assertTrue(service.canDiscardDraft(child));
|
}
|
@Test public void directDraftRemovalCannotBypassRemovePermission() {
|
currentDraftContext(); allow("files", Action.EDIT);
|
denied("REMOVE", () -> service.validateDraftChange(draft("A", "B"), Collections.emptyList()));
|
}
|
@Test public void restoringEditedContentRequiresEditWithoutRequiringReplace() {
|
currentDraftContext(); allow("files", Action.EDIT);
|
service.validateDraftDiscard(draft("A", "B"));
|
allow("files", Action.REPLACE);
|
denied("EDIT", () -> service.validateDraftDiscard(draft("A", "B")));
|
}
|
@Test public void discardOfUploadReplacementRequiresReplace() {
|
currentDraftContext(); allow("files", Action.EDIT);
|
UploadEditDraft d = draft("C", "D");
|
denied("REPLACE", () -> service.validateDraftDiscard(d));
|
allow("files", Action.REPLACE); service.validateDraftDiscard(d);
|
}
|
@Test public void discardOfRemovedAttachmentRequiresAdd() {
|
currentDraftContext(); allow("files", Action.EDIT);
|
UploadEditDraft d = draft("A", "B"); d.setCurrentJson("[]"); d.setEditOriginsJson(null);
|
denied("ADD", () -> service.validateDraftDiscard(d));
|
}
|
@Test public void missingProvenanceForOldEditedDraftCannotMasqueradeAsReplacement() {
|
allow("files", Action.REPLACE);
|
String id = "onlyoffice-edit-temp,tenant,lease,result.docx";
|
UploadEditDraft d = draft("A", id); d.setEditOriginsJson(null);
|
model.getDataNewMap().put("files", files(id));
|
denied("缺少编辑来源", () -> validate(d));
|
}
|
@Test public void anotherRecordDraftCannotBeUsedForEditAdoption() {
|
allow("files", Action.EDIT, Action.REPLACE);
|
UploadEditDraft d = draft("A", "B"); d.setRecordId("other-record");
|
model.getDataNewMap().put("files", files("B")); denied("上传来源", () -> validate(d));
|
}
|
|
@Test public void incompleteReadCannotBeTreatedAsNonWorkflowRecord() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
baseline.remove("flowTaskId");
|
when(forms.getFilePermissionDataInfo(eq(released), anyString(), any())).thenReturn(baseline);
|
denied("记录不存在", () -> service.prepare(model)); verifyNoInteractions(workflow);
|
}
|
@Test public void conflictingCaseChildKeysCannotHideRemoval() {
|
children();
|
Map<String, Object> row = new LinkedHashMap<>(); row.put("custom_id", "row-1");
|
row.put("files", files("A")); row.put("FILES", Collections.emptyList());
|
model.getDataNewMap().put("rows", Collections.singletonList(row));
|
denied("大小写冲突", () -> validate());
|
}
|
@Test public void permittedNullRetainsNativeNullRepresentation() {
|
allow("files", Action.REMOVE); model.getDataNewMap().put("files", null); validate();
|
assertNull(model.getDataNewMap().get("files"));
|
}
|
|
@Test public void revokedViewAlsoPreventsAdoptionOfEditedContent() {
|
allow("files", Action.EDIT); model.getDataNewMap().put("files", files("B"));
|
denied("VIEW", () -> validate(draft("A", "B")));
|
}
|
|
@Test public void templateSourceReadsNativeBaselineWithoutOnlineEditorAndRejectsRecordMismatch() {
|
VisualdevEntity released = new VisualdevEntity(); when(models.getReleaseInfo("model")).thenReturn(released);
|
when(forms.getFilePermissionDataInfo(eq(released), eq("record"), any())).thenReturn(baseline);
|
baseline.put("wenjian", "[{\"fileId\":\"A\",\"laiyuan_muban_id\":\"templateA\"}]");
|
assertEquals("templateA", service.dmsMainAttachmentBaseline(model).get(0).get("laiyuan_muban_id"));
|
verifyNoInteractions(workflow);
|
baseline.put("id", "other");
|
denied("记录不匹配", () -> service.dmsMainAttachmentBaseline(model));
|
}
|
|
@Test public void sameFileTemplateRestoreStillRequiresReplaceAndUsesBatchPermissions() {
|
permissions.setEnabled(true); allow("wenjian", Action.VIEW, Action.EDIT);
|
UploadEditDraft d = draft("A", "A"); d.setField("wenjian"); d.setEditOriginsJson("{}");
|
d.setBaselineJson("[{\"fileId\":\"A\",\"laiyuan_muban_id\":\"templateA\"}]");
|
d.setCurrentJson("[{\"fileId\":\"A\",\"laiyuan_muban_id\":\"templateB\"}]");
|
assertFalse(service.canDiscardDraft(d, permissions));
|
allow("wenjian", Action.VIEW, Action.EDIT, Action.REPLACE);
|
assertTrue(service.canDiscardDraft(d, permissions));
|
verifyNoInteractions(models, forms, workflow);
|
}
|
}
|
