package jnpf.dmsService;
|
|
import jnpf.base.UserInfo;
|
import jnpf.dmsEntity.permission.entity.DmsFileVersionEntity;
|
import jnpf.dmsEntity.permission.enums.DmsPermissionAction;
|
import jnpf.dmsEntity.permission.enums.DmsResourceType;
|
import jnpf.dmsEntity.preview.enums.DmsPreviewFormat;
|
import jnpf.dmsEntity.preview.form.DmsFilePreviewTicketRequest;
|
import jnpf.dmsEntity.preview.model.DmsFilePreviewTicket;
|
import jnpf.dmsEntity.preview.vo.DmsFilePreviewTicketVO;
|
import jnpf.dmsEntity.storage.entity.DmsFileObjectEntity;
|
import jnpf.dmsMapper.DmsFileObjectMapper;
|
import jnpf.dmsMapper.DmsFileVersionMapper;
|
import jnpf.dmsPermission.DmsCurrentIdentity;
|
import jnpf.dmsPermission.DmsPermissionError;
|
import jnpf.dmsPermission.DmsPermissionException;
|
import jnpf.dmsPermission.DmsPermissionExecutionContext;
|
import jnpf.dmsPermission.DmsPermissionGuard;
|
import jnpf.dmsPermission.DmsPermissionOperation;
|
import jnpf.dmsService.pdf.DmsPdfGenerationTaskService;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.params.ParameterizedTest;
|
import org.junit.jupiter.params.provider.ValueSource;
|
import org.mockito.ArgumentCaptor;
|
|
import java.util.UUID;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.anyLong;
|
import static org.mockito.Mockito.doThrow;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
class DmsFilePreviewServiceTest {
|
private final DmsCurrentIdentity currentIdentity = mock(DmsCurrentIdentity.class);
|
private final DmsPermissionGuard permissionGuard = mock(DmsPermissionGuard.class);
|
private final DmsFileVersionMapper versionMapper = mock(DmsFileVersionMapper.class);
|
private final DmsFileObjectMapper objectMapper = mock(DmsFileObjectMapper.class);
|
private final DmsFilePreviewTicketIssuer ticketIssuer = mock(DmsFilePreviewTicketIssuer.class);
|
private final DmsFileOperationLogService operationLogService = mock(DmsFileOperationLogService.class);
|
private final DmsWatermarkPreviewResolver watermarkPreviewResolver = mock(DmsWatermarkPreviewResolver.class);
|
private final DmsPreviewPreparationClient previewPreparationClient = mock(DmsPreviewPreparationClient.class);
|
private final DmsPdfGenerationTaskService pdfGenerationTaskService = mock(DmsPdfGenerationTaskService.class);
|
private final DmsFilePreviewService service = new DmsFilePreviewService(currentIdentity,
|
permissionGuard, versionMapper, objectMapper, ticketIssuer, operationLogService,
|
watermarkPreviewResolver, previewPreparationClient, pdfGenerationTaskService);
|
private final UUID documentId = UUID.fromString("018f0000-0000-7000-8000-000000000701");
|
private final UUID versionId = UUID.fromString("018f0000-0000-7000-8000-000000000702");
|
private final UUID operationId = UUID.fromString("018f0000-0000-7000-8000-000000000703");
|
|
@BeforeEach
|
void setUp() {
|
UserInfo user = new UserInfo();
|
user.setTenantId("tenant-1");
|
user.setUserId("user-1");
|
when(currentIdentity.requireUser()).thenReturn(user);
|
when(currentIdentity.tenantId(user)).thenReturn("tenant-1");
|
when(permissionGuard.execute(any(), any())).thenAnswer(invocation -> {
|
DmsPermissionOperation<?> operation = invocation.getArgument(1);
|
return operation.execute();
|
});
|
when(ticketIssuer.issue(any(DmsFilePreviewTicket.class),
|
org.mockito.ArgumentMatchers.eq(DmsFilePreviewService.TICKET_TTL_SECONDS)))
|
.thenReturn("preview-ticket");
|
when(watermarkPreviewResolver.resolve(any(), any(), any(), any()))
|
.thenReturn(java.util.Collections.emptyList());
|
when(previewPreparationClient.prepare(any())).thenAnswer(invocation -> invocation.getArgument(0));
|
}
|
|
@Test
|
void documentPreviewResolvesCurrentVersionAndGuardsExactVersion() {
|
DmsFileVersionEntity version = version();
|
when(versionMapper.selectCurrentEffective("tenant-1", documentId)).thenReturn(version);
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
when(objectMapper.selectByTenantAndFileVersionId("tenant-1", versionId)).thenReturn(fileObject());
|
|
long before = System.currentTimeMillis();
|
DmsFilePreviewTicketVO result = service.createTicket(request(DmsResourceType.DOCUMENT, documentId));
|
|
assertEquals(versionId, result.getFileVersionId());
|
assertEquals("quality-manual.docx", result.getFileName());
|
assertEquals("preview-ticket", result.getAccessTicket());
|
assertTrue(result.getExpiresAt().getTime() >= before + 299_000L);
|
|
ArgumentCaptor<DmsPermissionExecutionContext> contextCaptor =
|
ArgumentCaptor.forClass(DmsPermissionExecutionContext.class);
|
verify(permissionGuard).execute(contextCaptor.capture(), any());
|
DmsPermissionExecutionContext context = contextCaptor.getValue();
|
assertEquals(DmsResourceType.FILE_VERSION, context.getResourceType());
|
assertEquals(versionId, context.getResourceId());
|
assertEquals(DmsPermissionAction.READ, context.getActionCode());
|
assertEquals(operationId, context.getOperationId());
|
assertNotNull(context.getSessionExpiresAt());
|
|
ArgumentCaptor<DmsFilePreviewTicket> payloadCaptor =
|
ArgumentCaptor.forClass(DmsFilePreviewTicket.class);
|
verify(ticketIssuer).issue(payloadCaptor.capture(),
|
org.mockito.ArgumentMatchers.eq(DmsFilePreviewService.TICKET_TTL_SECONDS));
|
DmsFilePreviewTicket payload = payloadCaptor.getValue();
|
assertEquals("tenant-1", payload.getTenantId());
|
assertEquals("user-1", payload.getUserId());
|
assertEquals(versionId, payload.getFileVersionId());
|
assertEquals("seaweedfs-1", payload.getStoragePlatform());
|
assertEquals(DmsPreviewFormat.PDF, payload.getPreviewFormat());
|
verify(operationLogService).recordView(any(), org.mockito.ArgumentMatchers.eq("tenant-1"),
|
org.mockito.ArgumentMatchers.eq(documentId), org.mockito.ArgumentMatchers.eq(versionId),
|
org.mockito.ArgumentMatchers.eq("quality-manual.docx"),
|
org.mockito.ArgumentMatchers.eq(operationId));
|
verify(pdfGenerationTaskService).enqueueMissingEligible("tenant-1", versionId,
|
"quality-manual.docx", "a".repeat(64));
|
}
|
|
@ParameterizedTest
|
@ValueSource(strings = {"download", "print", "preview", "other", ""})
|
void previewTicketSelectsRequestedWatermarkScene(String watermarkType) {
|
DmsFileVersionEntity version = version();
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
when(objectMapper.selectByTenantAndFileVersionId("tenant-1", versionId)).thenReturn(fileObject());
|
DmsFilePreviewTicketRequest request = request(DmsResourceType.FILE_VERSION, versionId);
|
request.setWatermarkType(watermarkType);
|
|
service.createTicket(request);
|
|
if ("download".equals(watermarkType)) {
|
verify(watermarkPreviewResolver).resolveDownload(any(),
|
org.mockito.ArgumentMatchers.eq("tenant-1"),
|
org.mockito.ArgumentMatchers.eq(version),
|
org.mockito.ArgumentMatchers.eq(request));
|
} else if ("print".equals(watermarkType)) {
|
verify(watermarkPreviewResolver).resolvePrint(any(),
|
org.mockito.ArgumentMatchers.eq("tenant-1"),
|
org.mockito.ArgumentMatchers.eq(version),
|
org.mockito.ArgumentMatchers.eq(request));
|
} else {
|
verify(watermarkPreviewResolver).resolve(any(),
|
org.mockito.ArgumentMatchers.eq("tenant-1"),
|
org.mockito.ArgumentMatchers.eq(version),
|
org.mockito.ArgumentMatchers.eq(request));
|
}
|
}
|
|
@Test
|
void historicalPreviewUsesSelectedFileVersionWithoutResolvingCurrentVersion() {
|
DmsFileVersionEntity version = version();
|
version.setLifecycleStatus("INVALIDATED");
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
when(objectMapper.selectByTenantAndFileVersionId("tenant-1", versionId)).thenReturn(fileObject());
|
|
DmsFilePreviewTicketVO result = service.createTicket(
|
request(DmsResourceType.FILE_VERSION, versionId));
|
|
assertEquals(versionId, result.getFileVersionId());
|
verify(versionMapper, never()).selectCurrentEffective(any(), any());
|
ArgumentCaptor<DmsFilePreviewTicket> historical = ArgumentCaptor.forClass(DmsFilePreviewTicket.class);
|
verify(ticketIssuer).issue(historical.capture(), anyLong());
|
assertTrue(historical.getValue().isHistoricalAccess());
|
}
|
|
@Test
|
void uncontrolledVersionSkipsReadPermissionButKeepsPreviewPipeline() {
|
DmsFileVersionEntity version = version();
|
version.setShifouShoukong("no");
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
when(objectMapper.selectByTenantAndFileVersionId("tenant-1", versionId)).thenReturn(fileObject());
|
doThrow(DmsPermissionException.of(DmsPermissionError.PERMISSION_DENIED,
|
"no read permission")).when(permissionGuard).execute(any(), any());
|
|
DmsFilePreviewTicketVO result = service.createTicket(
|
request(DmsResourceType.FILE_VERSION, versionId));
|
|
assertEquals("preview-ticket", result.getAccessTicket());
|
verify(permissionGuard, never()).execute(any(), any());
|
verify(previewPreparationClient).prepare(any());
|
verify(operationLogService).recordView(any(), org.mockito.ArgumentMatchers.eq("tenant-1"),
|
org.mockito.ArgumentMatchers.eq(documentId), org.mockito.ArgumentMatchers.eq(versionId),
|
org.mockito.ArgumentMatchers.eq("quality-manual.docx"),
|
org.mockito.ArgumentMatchers.eq(operationId));
|
}
|
|
@Test
|
void controlledVersionWithoutReadPermissionIsRejected() {
|
DmsFileVersionEntity version = version();
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
doThrow(DmsPermissionException.of(DmsPermissionError.PERMISSION_DENIED,
|
"no read permission")).when(permissionGuard).execute(any(), any());
|
|
DmsPermissionException error = assertThrows(DmsPermissionException.class,
|
() -> service.createTicket(request(DmsResourceType.FILE_VERSION, versionId)));
|
|
assertEquals(DmsPermissionError.PERMISSION_DENIED, error.getError());
|
verify(ticketIssuer, never()).issue(any(), anyLong());
|
}
|
|
@Test
|
void returnsPreparedPdfMetadataInsteadOfOriginalDocxMetadata() {
|
DmsFileVersionEntity version = version();
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
when(objectMapper.selectByTenantAndFileVersionId("tenant-1", versionId)).thenReturn(fileObject());
|
when(previewPreparationClient.prepare(any())).thenAnswer(invocation -> {
|
DmsFilePreviewTicket prepared = invocation.getArgument(0);
|
prepared.setFileName("quality-manual.pdf");
|
prepared.setMimeType("application/pdf");
|
prepared.setSizeBytes(4096L);
|
return prepared;
|
});
|
|
DmsFilePreviewTicketVO result = service.createTicket(
|
request(DmsResourceType.FILE_VERSION, versionId));
|
|
assertEquals("quality-manual.pdf", result.getFileName());
|
assertEquals("application/pdf", result.getMimeType());
|
assertEquals(Long.valueOf(4096L), result.getSizeBytes());
|
}
|
|
@Test
|
void folderCannotBeUsedAsPreviewResource() {
|
DmsPermissionException error = assertThrows(DmsPermissionException.class,
|
() -> service.createTicket(request(DmsResourceType.FOLDER, documentId)));
|
|
assertEquals(DmsPermissionError.INVALID_REQUEST, error.getError());
|
verify(permissionGuard, never()).execute(any(), any());
|
verify(ticketIssuer, never()).issue(any(), anyLong());
|
}
|
|
@Test
|
void missingStoredObjectDoesNotIssueTicket() {
|
DmsFileVersionEntity version = version();
|
when(versionMapper.selectReadableByTenantAndId("tenant-1", versionId)).thenReturn(version);
|
|
DmsPermissionException error = assertThrows(DmsPermissionException.class,
|
() -> service.createTicket(request(DmsResourceType.FILE_VERSION, versionId)));
|
|
assertEquals(DmsPermissionError.RESOURCE_NOT_FOUND, error.getError());
|
verify(ticketIssuer, never()).issue(any(), anyLong());
|
}
|
|
@Test
|
void pendingVersionCannotIssuePreviewTicket() {
|
DmsPermissionException error = assertThrows(DmsPermissionException.class,
|
() -> service.createTicket(request(DmsResourceType.FILE_VERSION, versionId)));
|
|
assertEquals(DmsPermissionError.RESOURCE_NOT_FOUND, error.getError());
|
verify(permissionGuard, never()).execute(any(), any());
|
verify(ticketIssuer, never()).issue(any(), anyLong());
|
}
|
|
private DmsFilePreviewTicketRequest request(DmsResourceType type, UUID id) {
|
DmsFilePreviewTicketRequest request = new DmsFilePreviewTicketRequest();
|
request.setResourceType(type);
|
request.setResourceId(id);
|
request.setOperationId(operationId);
|
request.setPreviewFormat(DmsPreviewFormat.PDF);
|
return request;
|
}
|
|
private DmsFileVersionEntity version() {
|
DmsFileVersionEntity version = new DmsFileVersionEntity();
|
version.setId(versionId);
|
version.setDocumentId(documentId);
|
version.setFileName("quality-manual.docx");
|
version.setMimeType("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
|
version.setSizeBytes(2048L);
|
version.setChecksumSha256("a".repeat(64));
|
version.setShifouShoukong("yes");
|
return version;
|
}
|
|
private DmsFileObjectEntity fileObject() {
|
DmsFileObjectEntity object = new DmsFileObjectEntity();
|
object.setFileVersionId(versionId);
|
object.setStoragePlatform("seaweedfs-1");
|
object.setBucketName("jnpf-dms");
|
object.setBasePath("dms/");
|
object.setObjectPath("2026/08/24/document/");
|
object.setObjectName("quality-manual-v1.docx");
|
return object;
|
}
|
}
|
