package jnpf.elnService.template;
|
|
import feign.Request;
|
import feign.Response;
|
import jnpf.base.vo.DownloadVO;
|
import jnpf.elnEntity.ElnDocumentFileVo;
|
import jnpf.exception.DataException;
|
import jnpf.file.FileApi;
|
import jnpf.file.FileUploadApi;
|
import jnpf.model.ExportModel;
|
import jnpf.model.FileListVO;
|
import jnpf.model.upload.UploadFileModel;
|
import jnpf.util.JsonUtil;
|
import org.dromara.x.file.storage.core.FileInfo;
|
import org.junit.Test;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.Reader;
|
import java.nio.charset.Charset;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.Collection;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import static org.junit.Assert.assertArrayEquals;
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertFalse;
|
import static org.junit.Assert.assertNotEquals;
|
import static org.junit.Assert.assertTrue;
|
import static org.junit.Assert.fail;
|
|
public class ElnTemplateFileServiceTest {
|
|
@Test
|
public void copiesUniqueAuthoritativeDocxAndClosesResponses() {
|
Fixture fixture = new Fixture();
|
|
String attachments = fixture.service.copyDocx(sourceAttachments(), "target-template");
|
|
List<ElnDocumentFileVo> files = JsonUtil.getJsonToList(attachments, ElnDocumentFileVo.class);
|
assertEquals(1, files.size());
|
assertEquals("target-template.docx", files.get(0).getFileId());
|
assertEquals("docx", files.get(0).getFileExtension());
|
assertNotEquals("source.docx", files.get(0).getFileId());
|
assertArrayEquals(Fixture.DOCX, fixture.uploadApi.files.get("target-template.docx"));
|
assertEquals(Collections.singletonList("target-template.docx"), fixture.uploadApi.replacedIds);
|
assertEquals(2, fixture.uploadApi.closedBodies);
|
assertEquals("annex", fixture.uploadApi.downloads.get(0).getFolderName());
|
assertEquals("source.docx", fixture.uploadApi.downloads.get(0).getObjectName());
|
assertEquals("WebAnnexFile/", fixture.uploadApi.lastFolder);
|
assertEquals(0, fixture.uploadApi.uploadCalls);
|
}
|
|
@Test
|
public void retriesByOverwritingTheSameDeterministicTarget() {
|
Fixture fixture = new Fixture();
|
|
fixture.service.copyDocx(sourceAttachments(), "target-template");
|
fixture.service.copyDocx(sourceAttachments(), "target-template");
|
|
assertEquals(2, fixture.uploadApi.replacedIds.size());
|
assertEquals("target-template.docx", fixture.uploadApi.replacedIds.get(0));
|
assertEquals("target-template.docx", fixture.uploadApi.replacedIds.get(1));
|
assertEquals(2, fixture.uploadApi.files.size());
|
assertTrue(fixture.uploadApi.files.containsKey("target-template.docx"));
|
}
|
|
@Test
|
public void rejectsReplaceFalseWithoutReturningAttachmentJson() {
|
Fixture fixture = new Fixture();
|
fixture.uploadApi.replaceResult = false;
|
|
expectDataException(() -> fixture.service.copyDocx(sourceAttachments(), "target-template"));
|
|
assertEquals(1, fixture.uploadApi.replacedIds.size());
|
}
|
|
@Test
|
public void rejectsFailedTargetReadback() {
|
Fixture fixture = new Fixture();
|
fixture.uploadApi.failTargetReadback = true;
|
|
expectDataException(() -> fixture.service.copyDocx(sourceAttachments(), "target-template"));
|
}
|
|
@Test
|
public void rejectsTargetDigestMismatch() {
|
Fixture fixture = new Fixture();
|
fixture.uploadApi.corruptTargetReadback = true;
|
|
expectDataException(() -> fixture.service.copyDocx(sourceAttachments(), "target-template"));
|
}
|
|
@Test
|
public void rejectsAmbiguousEmptyAndOversizedSourceDocuments() {
|
Fixture fixture = new Fixture();
|
expectDataException(() -> fixture.service.copyDocx(
|
"[{\"fileId\":\"a.docx\",\"fileExtension\":\"docx\"},"
|
+ "{\"fileId\":\"b.docx\",\"fileExtension\":\"docx\"}]", "target"));
|
|
fixture.uploadApi.files.put("source.docx", new byte[0]);
|
expectDataException(() -> fixture.service.copyDocx(sourceAttachments(), "target"));
|
|
fixture.uploadApi.reportedLength = 50 * 1024 * 1024 + 1;
|
expectDataException(() -> fixture.service.copyDocx(sourceAttachments(), "target"));
|
}
|
|
@Test
|
public void acceptsUnknownContentLengthAfterReadingActualBytes() {
|
Fixture fixture = new Fixture();
|
fixture.uploadApi.reportedLength = -1;
|
|
String attachments = fixture.service.copyDocx(sourceAttachments(), "target-template");
|
|
assertTrue(attachments.contains("target-template.docx"));
|
}
|
|
private static String sourceAttachments() {
|
return "[{\"fileId\":\"source.docx\",\"name\":\"source.docx\","
|
+ "\"fileExtension\":\"docx\"}]";
|
}
|
|
private static void expectDataException(Runnable action) {
|
try {
|
action.run();
|
fail("预期抛出 DataException");
|
} catch (DataException expected) {
|
assertFalse(expected.getMessage().trim().isEmpty());
|
}
|
}
|
|
private static final class Fixture {
|
private static final byte[] DOCX = "docx-content".getBytes(StandardCharsets.UTF_8);
|
private final StubFileApi fileApi = new StubFileApi();
|
private final StubFileUploadApi uploadApi = new StubFileUploadApi();
|
private final ElnTemplateFileService service = new ElnTemplateFileService(fileApi, uploadApi);
|
|
private Fixture() {
|
uploadApi.files.put("source.docx", DOCX);
|
}
|
}
|
|
private static final class StubFileApi implements FileApi {
|
@Override
|
public String getPath(String type) {
|
assertEquals("annex", type);
|
return "WebAnnexFile/";
|
}
|
|
@Override
|
public DownloadVO exportFile(ExportModel exportModel) {
|
return null;
|
}
|
|
@Override
|
public String getLocalBasePath() {
|
return null;
|
}
|
|
@Override
|
public String getAllowPreviewFileType() {
|
return null;
|
}
|
|
@Override
|
public Boolean fileExists(String type, String fileName) {
|
return null;
|
}
|
}
|
|
private static final class StubFileUploadApi implements FileUploadApi {
|
private final Map<String, byte[]> files = new LinkedHashMap<>();
|
private final List<String> replacedIds = new ArrayList<>();
|
private final List<UploadFileModel> downloads = new ArrayList<>();
|
private boolean replaceResult = true;
|
private boolean failTargetReadback;
|
private boolean corruptTargetReadback;
|
private Integer reportedLength;
|
private int uploadCalls;
|
private int closedBodies;
|
private String lastFolder;
|
|
@Override
|
public FileInfo uploadFile(MultipartFile multipartFile, String folderName, String fileName) {
|
uploadCalls++;
|
return null;
|
}
|
|
@Override
|
public boolean replaceFile(MultipartFile multipartFile, String folderName, String fileName) {
|
replacedIds.add(fileName);
|
lastFolder = folderName;
|
if (replaceResult) {
|
try {
|
files.put(fileName, multipartFile.getBytes());
|
} catch (IOException e) {
|
throw new IllegalStateException(e);
|
}
|
}
|
return replaceResult;
|
}
|
|
@Override
|
public byte[] getByte(String fileName, String folderName) {
|
return null;
|
}
|
|
@Override
|
public List<FileListVO> getFileList(String folderName) {
|
return Collections.emptyList();
|
}
|
|
@Override
|
public Response downFile(UploadFileModel model) {
|
downloads.add(model);
|
boolean target = model.getObjectName().startsWith("target-");
|
if (target && failTargetReadback) {
|
return response(404, null);
|
}
|
byte[] bytes = files.get(model.getObjectName());
|
if (target && corruptTargetReadback && bytes != null) {
|
bytes = "different-content".getBytes(StandardCharsets.UTF_8);
|
}
|
return response(bytes == null ? 404 : 200, bytes);
|
}
|
|
private Response response(int status, byte[] bytes) {
|
return Response.builder()
|
.status(status)
|
.reason(status == 200 ? "OK" : "Not Found")
|
.request(Request.create(Request.HttpMethod.GET, "http://file/download",
|
Collections.<String, Collection<String>>emptyMap(), null, Charset.defaultCharset()))
|
.body(bytes == null ? null : new TrackingBody(bytes,
|
reportedLength == null ? bytes.length : reportedLength, this))
|
.build();
|
}
|
|
@Override
|
public FileInfo getFile(String fileId) {
|
return null;
|
}
|
|
@Override
|
public String getDefaultPlatform() {
|
return null;
|
}
|
|
@Override
|
public List<FileListVO> getVisualList(String folderName) {
|
return Collections.emptyList();
|
}
|
}
|
|
private static final class TrackingBody implements Response.Body {
|
private final byte[] bytes;
|
private final int length;
|
private final StubFileUploadApi owner;
|
|
private TrackingBody(byte[] bytes, int length, StubFileUploadApi owner) {
|
this.bytes = bytes;
|
this.length = length;
|
this.owner = owner;
|
}
|
|
@Override
|
public Integer length() {
|
return length;
|
}
|
|
@Override
|
public boolean isRepeatable() {
|
return true;
|
}
|
|
@Override
|
public InputStream asInputStream() {
|
return new ByteArrayInputStream(bytes);
|
}
|
|
@Override
|
public Reader asReader(Charset charset) {
|
throw new UnsupportedOperationException();
|
}
|
|
@Override
|
public void close() {
|
owner.closedBodies++;
|
}
|
}
|
}
|
