package jnpf.base.service;

import cn.dev33.satoken.stp.StpUtil;
import jnpf.base.ActionResult;
import jnpf.base.ModuleButtonApi;
import jnpf.base.entity.ModuleButtonEntity;
import jnpf.base.entity.VisualdevEntity;
import jnpf.base.model.button.ModuleButtonModel;
import jnpf.base.model.uploadedit.UploadEditContext;
import jnpf.base.util.FlowFormDataUtil;
import jnpf.exception.DataException;
import jnpf.flowable.WorkFlowApi;
import jnpf.flowable.entity.TaskEntity;
import jnpf.flowable.enums.TaskStatusEnum;
import jnpf.onlyoffice.UploadFileCapabilityApi;
import jnpf.flowable.entity.TemplateNodeEntity;
import jnpf.flowable.model.filepermission.FilePermissionView;
import jnpf.flowable.model.filepermission.FilePermissionPolicy.Action;
import jnpf.util.UserProvider;
import org.junit.Before;
import org.junit.Test;
import org.mockito.MockedStatic;
import org.springframework.beans.factory.ObjectProvider;
import java.util.*;
import static org.junit.Assert.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;

public class UploadEditAccessTest {
    private UploadEditAccess access;
    private UploadEditContext context;
    private WorkFlowApi workflow;
    private VisualdevEntity model;
    private UploadFileCapabilityApi capabilities;
    private FlowFormDataUtil form;
    private ModuleButtonApi buttons;
    private Map<String, Object> data;
    private VisualdevService modelService;
    private UploadEditReadService sharedReads;
    @Before @SuppressWarnings("unchecked") public void setup() {
        jnpf.util.context.SpringContext.setApplicationContext(mock(org.springframework.context.ApplicationContext.class));
        ObjectProvider<VisualdevService> models = mock(ObjectProvider.class);
        modelService = mock(VisualdevService.class); when(models.getObject()).thenReturn(modelService);
        ObjectProvider<FlowFormDataUtil> forms = mock(ObjectProvider.class);
        form = mock(FlowFormDataUtil.class); when(forms.getObject()).thenReturn(form);
        buttons = mock(ModuleButtonApi.class);
        workflow = mock(WorkFlowApi.class);
        when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.legacy("alias", "model"));
        capabilities = mock(UploadFileCapabilityApi.class);
        ActionResult<Map<String, Boolean>> options = new ActionResult<>(); options.setCode(200);
        options.setData(Collections.singletonMap("editEnabled", true)); when(capabilities.options()).thenReturn(options);
        model = new VisualdevEntity(); model.setFormData("{\"fields\":[{\"__vModel__\":\"files\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        model.setColumnData("{}"); when(modelService.getReleaseInfo("model")).thenReturn(model);
        sharedReads = mock(UploadEditReadService.class); when(sharedReads.model("model")).thenReturn(model);
        when(sharedReads.dmsAttachment(any(), any(), anyMap())).thenReturn(null);
        data = new HashMap<>(); data.put("id", "real-record"); data.put("flowTaskId", "alias");
        data.put("files", Collections.singletonList(Collections.singletonMap("fileId", "source")));
        when(form.getEditDataInfo(eq(model), anyString(), any())).thenReturn(data);
        access = new UploadEditAccess(models, forms, workflow, new UploadFilePermissionQuery(workflow, mock(ObjectProvider.class)), capabilities, buttons, sharedReads);
        context = new UploadEditContext(); context.setModelId("model"); context.setRecordId("alias"); context.setField("files");
    }
    @Test public void copyLifecycleOnlyAppliesToUnsavedDmsAuditAttachmentFields() {
        context.setRecordId(null); context.setField("wenjian");
        for (String table : List.of("dms_wenjian_xinzeng_shenhe", "dms_wenjian_xiuding_shenhe")) {
            model.setFormData("{\"tableName\":\""+table+"\"}");
            assertTrue(access.isDmsAuditTemporary(context));
            context.setTaskId("task"); assertFalse(access.isDmsAuditTemporary(context)); context.setTaskId(null);
            context.setRecordId("saved"); assertFalse(access.isDmsAuditTemporary(context)); context.setRecordId(null);
        }
        model.setFormData("{\"tableName\":\"other_business\"}"); assertFalse(access.isDmsAuditTemporary(context));
        model.setFormData("{}"); assertFalse(access.isDmsAuditTemporary(context));
    }
    @Test public void savedDmsAuditRejectsLegacyPermissionsForBothReadAndEdit() {
        model.setFormData("{\"tableName\":\"dms_wenjian_xiuding_shenhe\",\"fields\":[{\"__vModel__\":\"wenjian\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        context.setField("wenjian");
        for (boolean shared : List.of(false, true)) {
            try {
                if (shared) access.sharedBaseline(context, "owner"); else access.checkedBaseline(context, "owner");
                fail("legacy DMS permissions must be rejected");
            } catch (DataException expected) { assertEquals(UploadEditAccess.DMS_INCOMPATIBLE, expected.getMessage()); }
        }
    }
    @Test public void newDmsAuditStillUsesCurrentTemporaryAuthorization() {
        model.setFormData("{\"tableName\":\"dms_wenjian_xinzeng_shenhe\",\"fields\":[{\"__vModel__\":\"wenjian\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        context.setField("wenjian"); context.setRecordId(null);
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            access.authorizeTemporary(context, "owner");
            auth.verify(() -> StpUtil.checkPermission("model"));
        }
    }
    @Test public void nonWorkflowRecordUsesNativeIdAndOrdinaryPermission() {
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            assertEquals("source", access.baseline(context, "owner").get(0).get("fileId"));
            assertEquals("real-record", context.getRecordId());
            auth.verify(() -> StpUtil.checkPermission("model"));
        }
    }
    @Test public void qianpiyePluginRequiresExplicitPublishedFieldSwitch() {
        assertFalse(access.qianpiyeAnnotatorEnabled(context));
        model.setFormData("{\"fields\":[{\"__vModel__\":\"files\",\"onlineEdit\":true,\"qianpiyeAnnotatorEnabled\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        assertTrue(access.qianpiyeAnnotatorEnabled(context));
        model.setFormData("{\"fields\":[{\"__vModel__\":\"files\",\"onlineEdit\":false,\"qianpiyeAnnotatorEnabled\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        assertFalse(access.qianpiyeAnnotatorEnabled(context));
    }
    @Test public void unassociatedEditButtonDoesNotRestrictOnlineAttachmentEditing() {
        model.setColumnData("{\"useBtnPermission\":true,\"onlyAssociatedBtnPermission\":true}");
        when(buttons.getListByModuleIdsForPermission(any(ModuleButtonModel.class))).thenReturn(Collections.emptyList());
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            access.baseline(context, "owner");
            auth.verify(() -> StpUtil.checkPermission("model"));
            auth.verify(() -> StpUtil.checkPermission("model::btn_edit"), never());
        }
    }
    @Test public void associatedEditButtonStillRequiresPermission() {
        model.setColumnData("{\"useBtnPermission\":true,\"onlyAssociatedBtnPermission\":true}");
        ModuleButtonEntity resource = new ModuleButtonEntity(); resource.setEnCode("btn_edit");
        when(buttons.getListByModuleIdsForPermission(any(ModuleButtonModel.class))).thenReturn(Collections.singletonList(resource));
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            access.baseline(context, "owner");
            auth.verify(() -> StpUtil.checkPermission("model::btn_edit"));
            verify(buttons).getListByModuleIdsForPermission(argThat(query -> query.getIds().equals(Collections.singletonList("model"))));
        }
    }
    @Test public void associatedAddButtonStillRequiresPermissionForNewRecords() {
        model.setColumnData("{\"useBtnPermission\":true,\"onlyAssociatedBtnPermission\":true}");
        context.setRecordId("");
        ModuleButtonEntity resource = new ModuleButtonEntity(); resource.setEnCode("btn_add");
        when(buttons.getListByModuleIdsForPermission(any(ModuleButtonModel.class))).thenReturn(Collections.singletonList(resource));
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            access.baseline(context, "owner");
            auth.verify(() -> StpUtil.checkPermission("model::btn_add"));
        }
    }
    @Test public void defaultModeRetainsStrictButtonPermission() {
        model.setColumnData("{\"useBtnPermission\":true}");
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            access.baseline(context, "owner");
            auth.verify(() -> StpUtil.checkPermission("model::btn_edit"));
            verifyNoInteractions(buttons);
        }
    }
    @Test public void missingAssociationResponseKeepsExistingPermissionCheck() {
        model.setColumnData("{\"useBtnPermission\":true,\"onlyAssociatedBtnPermission\":true}");
        when(buttons.getListByModuleIdsForPermission(any(ModuleButtonModel.class))).thenReturn(null);
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            access.baseline(context, "owner");
            auth.verify(() -> StpUtil.checkPermission("model::btn_edit"));
        }
    }
    @Test public void nativeMenuDraftWithoutTaskStillChecksOrdinaryPermissions() {
        data.put(FilePermissionNativeDraft.STATE_KEY, nativeState(0));
        when(form.getFilePermissionDataInfo(eq(model), eq("real-record"), any())).thenReturn(data);
        when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "TASK_NOT_FOUND"));
        try (MockedStatic<StpUtil> auth = mockStatic(StpUtil.class)) {
            assertFalse(access.checkedBaseline(context, "owner").isControlled());
            assertTrue(access.allowDownload(context));
            auth.verify(() -> StpUtil.checkPermission("model"));
        }
    }
    @Test public void absentTaskCannotRescueRunningDeletedOrUnverifiedRecord() {
        when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "TASK_NOT_FOUND"));
        when(form.getFilePermissionDataInfo(eq(model), anyString(), any())).thenReturn(data);
        rejects(() -> access.baseline(context, "owner"));
        data.put(FilePermissionNativeDraft.STATE_KEY, nativeState(1));
        rejects(() -> access.baseline(context, "owner"));
        Map<String,Object> state = nativeState(0); state.put("deleteMark", 1);
        data.put(FilePermissionNativeDraft.STATE_KEY, state);
        rejects(() -> access.baseline(context, "owner"));
        data.put(FilePermissionNativeDraft.STATE_KEY, nativeState(0));
        context.setTaskId("alias");
        rejects(() -> access.baseline(context, "owner"));
    }
    @Test public void nativeDraftCannotConvertNetworkFailureIntoLegacy() {
        data.put(FilePermissionNativeDraft.STATE_KEY, nativeState(0));
        when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "PERMISSION_UNAVAILABLE"));
        rejects(() -> access.baseline(context, "owner"));
        rejects(() -> access.allowDownload(context));
        verify(form, never()).getFilePermissionDataInfo(any(), anyString(), any());
    }
    private Map<String,Object> nativeState(int status) {
        Map<String,Object> state = new HashMap<>(); state.put("flowId", "flow"); state.put("flowState", status); state.put("deleteMark", null); return state;
    }
    @Test(expected = DataException.class) public void disabledCapabilityRejectsAccess() {
        ActionResult<Map<String, Boolean>> options = new ActionResult<>(); options.setCode(200);
        options.setData(Collections.singletonMap("editEnabled", false)); when(capabilities.options()).thenReturn(options);
        access.baseline(context, "owner");
    }
    @Test(expected = DataException.class) public void workflowCannotBeEditedByAnotherUser() {
        TaskEntity task = new TaskEntity(); task.setId("alias"); task.setCreatorUserId("someone-else"); task.setStatus(TaskStatusEnum.TO_BE_SUBMIT.getCode());
        when(workflow.getInfoSubmit("alias")).thenReturn(task); access.baseline(context, "owner");
    }
    @Test(expected = DataException.class) public void nonDraftWorkflowCannotBeEditedEvenByCreator() {
        TaskEntity task = new TaskEntity(); task.setId("alias"); task.setCreatorUserId("owner"); task.setStatus(-999);
        when(workflow.getInfoSubmit("alias")).thenReturn(task); access.baseline(context, "owner");
    }
    @Test(expected = DataException.class) public void missingWorkflowIsNotTreatedAsOrdinaryRecord() {
        context.setTaskId("task"); access.baseline(context, "owner");
    }
    @Test(expected = DataException.class) public void disabledParentCannotBeBypassedThroughChildField() {
        model.setFormData("{\"fields\":[{\"__vModel__\":\"rows\",\"disabled\":true,\"__config__\":{\"jnpfKey\":\"table\",\"children\":[{\"__vModel__\":\"files\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}}]}");
        context.setParentField("rows"); context.setRowId("row"); access.baseline(context, "owner");
    }
    @Test public void downloadUsesReleasedFieldAndDefaultsOnlyForOldSchemas() {
        assertTrue(access.allowDownload(context));
        model.setFormData("{\"fields\":[{\"__vModel__\":\"files\",\"allowDownload\":false,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        assertFalse(access.allowDownload(context));
        model.setFormData(model.getFormData().replace("false", "\"false\""));
        assertFalse(access.allowDownload(context));
    }
    @Test public void downloadSeparatesMainAndChildFieldsWithSameName() {
        model.setFormData("{\"fields\":[{\"__vModel__\":\"files\",\"allowDownload\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}},{\"__vModel__\":\"rows\",\"__config__\":{\"jnpfKey\":\"table\",\"children\":[{\"__vModel__\":\"files\",\"allowDownload\":false,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}}]}");
        assertTrue(access.allowDownload(context));
        context.setParentField("rows");
        assertFalse(access.allowDownload(context));
    }
    @Test(expected = DataException.class) public void missingDownloadFieldDoesNotDefaultToAllowed() {
        context.setField("missing"); access.allowDownload(context);
    }

    @Test public void oldDraftStillUsesNativeCreatorAndNodePermissions() {
        TaskEntity task = task("owner", 0);
        TemplateNodeEntity start = new TemplateNodeEntity(); start.setNodeType("start"); start.setFormId("model");
        start.setNodeJson("{\"formOperates\":[{\"id\":\"files\",\"write\":true}]}");
        when(workflow.getNodesByFlowId(task.getFlowId())).thenReturn(List.of(start));
        assertEquals("source", access.baseline(context, "owner").get(0).get("fileId"));
        start.setNodeJson("{\"formOperates\":[{\"id\":\"files\",\"write\":false}]}");
        rejects(() -> access.baseline(context, "owner"));
    }
    @Test public void controlledCurrentHandlerCanEditWhileCreatorRuleNoLongerApplies() {
        task("creator", 1);
        when(workflow.filePermissions("alias", "model")).thenReturn(controlled(true, false));
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("handler");
            assertEquals("source", access.baseline(context, "handler").get(0).get("fileId"));
            assertEquals("alias", context.getTaskId());
            verify(workflow, never()).getNodesByFlowId(any());
        }
    }
    @Test public void controlledDenialAndUnavailableDoNotFallBackToCreator() {
        task("owner", 0);
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("owner");
            when(workflow.filePermissions("alias", "model")).thenReturn(controlled(false, true));
            rejects(() -> access.baseline(context, "owner"));
            when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "OFFLINE"));
            rejects(() -> access.baseline(context, "owner"));
            when(workflow.filePermissions("alias", "model")).thenReturn(null);
            rejects(() -> access.baseline(context, "owner"));
        }
    }
    @Test public void rejectsForeignPermissionContextAndOwner() {
        task("creator", 1);
        FilePermissionView view = controlled(true, true);
        when(workflow.filePermissions("alias", "model")).thenReturn(view);
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("handler");
            rejects(() -> access.baseline(context, "someone-else"));
            view.setTaskId("other-task");
            rejects(() -> access.baseline(context, "handler"));
        }
    }
    @Test public void downloadRechecksActualRecordTaskAndDoesNotRequireEditing() {
        context.setTaskId("forged-task");
        when(workflow.filePermissions("alias", "model")).thenReturn(controlled(false, true));
        assertTrue(access.allowDownload(context));
        when(workflow.filePermissions("alias", "model")).thenReturn(controlled(true, false));
        assertFalse(access.allowDownload(context));
        verify(workflow, never()).filePermissions(eq("forged-task"), any());
    }
    @Test public void controlledMarkerComesFromRuntimeAndMissingTaskCannotDowngrade() {
        when(workflow.filePermissions("alias", "model")).thenReturn(controlled(true, true));
        rejects(() -> access.checkedBaseline(context, "handler"));
        task("creator", 1);
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("handler");
            assertTrue(access.checkedBaseline(context, "handler").isControlled());
            assertEquals("alias", context.getTaskId());
        }
    }
    @Test public void missingTaskWithUnavailableRuntimeCannotTakeOrdinaryPath() {
        when(workflow.filePermissions("alias", "model")).thenReturn(null);
        rejects(() -> access.baseline(context, "owner"));
        when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "OFFLINE"));
        rejects(() -> access.baseline(context, "owner"));
    }
    private TaskEntity task(String creator, int status) {
        TaskEntity task = new TaskEntity(); task.setId("alias"); task.setCreatorUserId(creator);
        task.setStatus(status); task.setFlowId("flow");
        when(workflow.getInfoSubmit("alias")).thenReturn(task); return task;
    }
    private FilePermissionView controlled(boolean edit, boolean download) {
        FilePermissionView view = new FilePermissionView(); view.setTaskId("alias"); view.setFormId("model");
        view.setStatus("ready"); view.setRevision("state");
        FilePermissionView.FieldAccess field = new FilePermissionView.FieldAccess(); field.setStatus("ready");
        field.setActions(Map.of(Action.EDIT, edit, Action.VIEW, true, Action.DOWNLOAD, download));
        view.getFields().put("files", field); return view;
    }

    private static void rejects(Runnable action) {
        try { action.run(); } catch (DataException expected) { return; }
        fail("expected access denial");
    }

    @Test public void sharedReadWorksForViewerWithoutGlobalEditingCapability() {
        task("creator", 1); when(workflow.filePermissions("alias", "model")).thenReturn(controlled(false,false));
        when(capabilities.options()).thenThrow(new IllegalStateException("edit disabled"));
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("viewer");
            assertEquals("source",access.sharedBaseline(context,"viewer").getFiles().get(0).get("fileId"));
            verifyNoInteractions(capabilities);
            context.setTaskId("other"); rejects(() -> access.sharedBaseline(context,"viewer"));
        }
    }

    @Test public void sharedReadUsesOneDefinitionAndRechecksItOnEachRequest() {
        task("creator", 1);
        context.setField("wenjian"); data.put("wenjian", data.get("files"));
        FilePermissionView view = controlled(false, false);
        view.getFields().put("wenjian", view.getFields().get("files"));
        when(workflow.filePermissions("alias", "model")).thenReturn(view);
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("viewer");
            for (String table : List.of("dms_wenjian_xinzeng_shenhe", "dms_wenjian_xiuding_shenhe", "other_business")) {
                model.setFormData("{\"tableName\":\"" + table + "\",\"fields\":[{\"__vModel__\":\"wenjian\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
                clearInvocations(sharedReads);
                UploadEditAccess.CheckedBaseline result = access.sharedBaseline(context, "viewer");
                assertEquals(!"other_business".equals(table), result.isDmsAudit());
                assertEquals("source", result.getFiles().get(0).get("fileId"));
                verify(sharedReads, times(1)).model("model");
                verify(modelService, never()).getReleaseInfo("model");
            }
            when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "OFFLINE"));
            rejects(() -> access.sharedBaseline(context, "viewer"));
        }
    }

    @Test public void sharedDmsReadUsesRawProjectionAndNeverLoadsNativeDisplayData() {
        task("creator", 1); context.setField("wenjian"); data.put("wenjian", data.get("files"));
        model.setFormData("{\"tableName\":\"dms_wenjian_xinzeng_shenhe\",\"fields\":[{\"__vModel__\":\"wenjian\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        FilePermissionView view = controlled(false, false); view.getFields().put("wenjian", view.getFields().get("files"));
        when(workflow.filePermissions("alias", "model")).thenReturn(view);
        when(sharedReads.dmsAttachment(eq(model), eq(context), anyMap())).thenReturn(data);
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("viewer");
            assertEquals("source", access.sharedBaseline(context, "viewer").getFiles().get(0).get("fileId"));
            verifyNoInteractions(form, modelService);
            when(sharedReads.dmsAttachment(eq(model), eq(context), anyMap())).thenThrow(new DataException("query failed"));
            rejects(() -> access.sharedBaseline(context, "viewer"));
            verifyNoInteractions(form, modelService);
        }
    }

    @Test public void batchSharesDefinitionAndPermissionsButNotAcrossRequests() {
        task("creator", 1); context.setField("wenjian"); data.put("wenjian", data.get("files"));
        model.setFormData("{\"tableName\":\"dms_wenjian_xinzeng_shenhe\",\"fields\":[{\"__vModel__\":\"wenjian\",\"onlineEdit\":true,\"__config__\":{\"jnpfKey\":\"uploadFile\"}}]}");
        FilePermissionView view = controlled(false, false); view.getFields().put("wenjian", view.getFields().get("files"));
        when(workflow.filePermissions("alias", "model")).thenReturn(view);
        when(sharedReads.dmsAttachment(eq(model), any(), anyMap())).thenReturn(data);
        try (MockedStatic<UserProvider> users = mockStatic(UserProvider.class)) {
            users.when(UserProvider::getLoginUserId).thenReturn("viewer");
            assertEquals(2, access.sharedBaselines(List.of(context, context), "viewer").size());
            verify(sharedReads, times(1)).model("model");
            verify(workflow, times(1)).filePermissions("alias", "model");
            verify(workflow, times(1)).getInfoSubmit("alias");
            when(workflow.filePermissions("alias", "model")).thenReturn(FilePermissionView.unavailable("alias", "model", "OFFLINE"));
            rejects(() -> access.sharedBaselines(List.of(context), "viewer"));
        }
    }
    @Test public void batchRejectsCrossRecordBeforeAnyReads() {
        UploadEditContext other = new UploadEditContext(); other.setModelId("model"); other.setRecordId("other"); other.setField("files");
        rejects(() -> access.sharedBaselines(List.of(context, other), "viewer"));
        verifyNoInteractions(sharedReads);
    }
}