package jnpf.elnService.impl;
|
|
import jnpf.base.ActionResult;
|
import jnpf.eln.RecordFreezeCheckBatch;
|
import jnpf.eln.RecordFreezeCheckRequest;
|
import jnpf.eln.RecordFreezeCheckResult;
|
import jnpf.eln.RecordFreezeReleaseRequest;
|
import jnpf.elnEntity.field.ElnFieldVersionEntity;
|
import jnpf.elnEntity.formula.ElnTemplateFormulaBindingEntity;
|
import jnpf.elnEntity.runtime.ElnRecordEntity;
|
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
|
import jnpf.elnEntity.runtime.ElnRecordFormulaCalculationResult;
|
import jnpf.elnEntity.runtime.ElnRecordRepeatRowEntity;
|
import jnpf.elnEntity.runtime.ElnRecordRepeatValueEntity;
|
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
|
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
|
import jnpf.elnMapper.ElnFieldVersionMapper;
|
import jnpf.elnMapper.ElnRecordFieldValueMapper;
|
import jnpf.elnMapper.ElnRecordMapper;
|
import jnpf.elnMapper.ElnRecordRepeatValueMapper;
|
import jnpf.elnMapper.ElnRecordRevisionMapper;
|
import jnpf.elnMapper.ElnRecordSaveOperationMapper;
|
import jnpf.elnMapper.ElnTemplateBindingMapper;
|
import jnpf.elnMapper.ElnTemplateFormulaBindingMapper;
|
import jnpf.elnService.ElnRecordFormulaCalculationService;
|
import jnpf.elnService.ElnCrossTemplateSnapshotResolver;
|
import jnpf.elnService.ElnRecordSourceSyncOperationCoordinator;
|
import jnpf.elnService.field.ElnTestResultFields;
|
import jnpf.elnService.template.ElnTemplateDocumentEvidence;
|
import jnpf.elnService.template.docx.DocxControlSnapshot;
|
import jnpf.onlyoffice.RecordRevisionFenceApi;
|
import org.junit.Before;
|
import org.junit.Test;
|
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.List;
|
import java.math.BigDecimal;
|
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertFalse;
|
import static org.junit.Assert.assertTrue;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.anyString;
|
import static org.mockito.ArgumentMatchers.eq;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.when;
|
|
public class ElnRecordFreezeCheckServiceImplTest {
|
private ElnRecordMapper recordMapper;
|
private ElnRecordRevisionMapper revisionMapper;
|
private ElnRecordFieldValueMapper valueMapper;
|
private ElnRecordRepeatValueMapper repeatValueMapper;
|
private ElnRecordSaveOperationMapper operationMapper;
|
private ElnTemplateBindingMapper bindingMapper;
|
private ElnTemplateFormulaBindingMapper formulaBindingMapper;
|
private ElnFieldVersionMapper versionMapper;
|
private ElnRecordFormulaCalculationService calculation;
|
private ElnTemplateDocumentEvidence evidence;
|
private RecordRevisionFenceApi fence;
|
private ElnCrossTemplateSnapshotResolver crossTemplateSnapshotResolver;
|
private ElnRecordSourceSyncOperationCoordinator sourceSyncOperations;
|
private ElnRecordFreezeCheckServiceImpl service;
|
|
@Before
|
public void setUp() {
|
recordMapper = mock(ElnRecordMapper.class);
|
revisionMapper = mock(ElnRecordRevisionMapper.class);
|
valueMapper = mock(ElnRecordFieldValueMapper.class);
|
repeatValueMapper = mock(ElnRecordRepeatValueMapper.class);
|
operationMapper = mock(ElnRecordSaveOperationMapper.class);
|
bindingMapper = mock(ElnTemplateBindingMapper.class);
|
formulaBindingMapper = mock(ElnTemplateFormulaBindingMapper.class);
|
versionMapper = mock(ElnFieldVersionMapper.class);
|
calculation = mock(ElnRecordFormulaCalculationService.class);
|
evidence = mock(ElnTemplateDocumentEvidence.class);
|
fence = mock(RecordRevisionFenceApi.class);
|
crossTemplateSnapshotResolver = mock(ElnCrossTemplateSnapshotResolver.class);
|
sourceSyncOperations = mock(ElnRecordSourceSyncOperationCoordinator.class);
|
service = new ElnRecordFreezeCheckServiceImpl(recordMapper, revisionMapper, valueMapper,
|
repeatValueMapper,
|
operationMapper, bindingMapper, formulaBindingMapper, versionMapper, calculation, evidence, fence,
|
new ElnRecordFreezeCheckServiceImpl.TenantRoute() {
|
@Override public void switchTo(String tenantId) { }
|
@Override public void clear() { }
|
}, crossTemplateSnapshotResolver, sourceSyncOperations);
|
}
|
|
@Test
|
public void returnsNotApplicableForItemsWithoutElnRecord() {
|
RecordFreezeCheckBatch batch = service.prepare(request("item-1"));
|
assertEquals(RecordFreezeCheckResult.NOT_APPLICABLE, batch.getItems().get(0).getStatus());
|
}
|
|
@Test
|
public void blocksFreezeWhileSourceSynchronizationAwaitsDocumentConfirmation() {
|
arrangeRecord("item-1", "value", "value", 0, "SUCCESS", "PRIMARY", "field-1");
|
when(sourceSyncOperations.hasPendingDocumentConfirmation("tenant-1", "record-1"))
|
.thenReturn(true);
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().stream().anyMatch(issue ->
|
"SOURCE_SYNC_DOCUMENT_PENDING".equals(issue.getCode())));
|
}
|
|
@Test
|
public void usesRecalculatedValueForDocumentComparisonAndKeepsFenceUntilRelease() {
|
arrangeRecord("item-1", "old", "new", 0, "SUCCESS", "PRIMARY", "field-1");
|
when(calculation.recalculateAll(anyString(), any(), any(), any(), anyString(), anyString())).thenAnswer(invocation -> {
|
ElnRecordFieldValueEntity value = ((List<ElnRecordFieldValueEntity>) invocation.getArgument(3)).get(0);
|
value.setZhiWenben("new");
|
value.setJisuanZhuangtai("SUCCESS");
|
return Collections.singletonList(value);
|
});
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(result.getDiagnostics().toString(), RecordFreezeCheckResult.READY, result.getStatus());
|
assertTrue(result.getReleaseToken().startsWith("freeze:op-1:item-1"));
|
verify(fence).acquireForOperation("tenant-1", "record-1", "record.docx", "annex", "op-1:item-1");
|
RecordFreezeReleaseRequest release = new RecordFreezeReleaseRequest();
|
release.setTenantId("tenant-1");
|
release.setOperationCode("op-1");
|
release.setTestWorkItemIds(Collections.singletonList("item-1"));
|
assertTrue(service.release(release));
|
verify(fence).release("tenant-1", "record-1", "record.docx", "annex", "freeze:op-1:item-1");
|
}
|
|
@Test
|
public void returnsStableTestSubmissionValuesOnlyForReadyRecord() {
|
arrangeRecord("item-1", "expected", "expected", 0, "SUCCESS", "PRIMARY", "field-1");
|
when(calculation.recalculateAll(anyString(), any(), any(), any(), anyString(), anyString()))
|
.thenReturn(Collections.emptyList());
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.READY, result.getStatus());
|
assertEquals("ELN 检验结果", result.getTestResult());
|
assertEquals("compliant", result.getTestConclusion());
|
}
|
|
@Test
|
public void aggregatesRequiredFormulaDocumentReferenceAndConcurrencyIssues() {
|
arrangeRecord("item-1", "", "x", 1, "ERROR", "WRONG_ROLE", "field-1");
|
ElnTemplateBindingEntity reference = binding("reference-1", "REFERENCE", "eln.ref.field", "field-other");
|
reference.setYinyongShiliId("binding-1");
|
when(bindingMapper.selectList(any())).thenReturn(Arrays.asList(binding("binding-1", "PRIMARY", "eln.field.field", "field-1"), reference));
|
when(operationMapper.selectCount(any())).thenReturn(1L);
|
when(calculation.recalculateAll(anyString(), any(), any(), any(), anyString(), anyString())).thenReturn(Collections.emptyList());
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(hasCategory(result, "REQUIRED"));
|
assertTrue(hasCategory(result, "FORMULA"));
|
assertTrue(hasCategory(result, "DOCUMENT"));
|
assertTrue(hasCategory(result, "REFERENCE"));
|
assertTrue(hasCategory(result, "CONCURRENCY"));
|
}
|
|
@Test
|
public void blocksRecordWhoseConfiguredSourceSnapshotWasNotInitialized() {
|
arrangeRecord("item-1", "legacy value", "legacy value", 0,
|
"SUCCESS", "PRIMARY", "field-1");
|
when(versionMapper.selectById(anyString())).thenAnswer(invocation -> {
|
String id = invocation.getArgument(0);
|
ElnFieldVersionEntity version = fieldVersion(id,
|
"version-result".equals(id) ? "TEXTAREA"
|
: "version-conclusion".equals(id) ? "SELECT" : "TEXT",
|
"version-result".equals(id) || "version-conclusion".equals(id) ? 1 : 0);
|
if ("version-1".equals(id)) {
|
version.setBangdingPeizhi("{\"read\":{\"source\":\"LIMS_TASK\","
|
+ "\"property\":\"verification.sample_name\",\"propertyRevision\":1}}");
|
}
|
return version;
|
});
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().toString(), result.getDiagnostics().stream().anyMatch(issue ->
|
"SOURCE_INITIALIZATION_INCOMPLETE".equals(issue.getCode())
|
&& "binding-1".equals(issue.getTargetBindingId())
|
&& "field-1".equals(issue.getTargetFieldCode())));
|
}
|
|
@Test
|
public void marksMissingConfiguredSourceValueAsInitializationIncomplete() {
|
arrangeRecord("item-1", "legacy value", "legacy value", 0,
|
"SUCCESS", "PRIMARY", "field-1");
|
when(valueMapper.selectList(any())).thenReturn(Arrays.asList(
|
value("binding-result", "version-result",
|
ElnTestResultFields.RESULT, "ELN 检验结果"),
|
value("binding-conclusion", "version-conclusion",
|
ElnTestResultFields.CONCLUSION, "compliant")));
|
when(versionMapper.selectById(anyString())).thenAnswer(invocation -> {
|
String id = invocation.getArgument(0);
|
ElnFieldVersionEntity version = fieldVersion(id,
|
"version-result".equals(id) ? "TEXTAREA"
|
: "version-conclusion".equals(id) ? "SELECT" : "TEXT",
|
"version-result".equals(id) || "version-conclusion".equals(id) ? 1 : 0);
|
if ("version-1".equals(id)) {
|
version.setBangdingPeizhi("{\"read\":{\"source\":\"LIMS_TASK\","
|
+ "\"property\":\"verification.sample_name\",\"propertyRevision\":1}}");
|
}
|
return version;
|
});
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().toString(), result.getDiagnostics().stream().anyMatch(issue ->
|
"SOURCE_INITIALIZATION_INCOMPLETE".equals(issue.getCode())
|
&& "binding-1".equals(issue.getTargetBindingId())
|
&& "field-1".equals(issue.getTargetFieldCode())));
|
}
|
|
@Test
|
public void allowsRequiredConfiguredDecimalSnapshotToFreeze() {
|
arrangeConfiguredStructuredValue("DECIMAL", "12.34",
|
new BigDecimal("12.340"), null);
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(result.getDiagnostics().toString(), RecordFreezeCheckResult.READY, result.getStatus());
|
}
|
|
@Test
|
public void allowsRequiredConfiguredDateSnapshotToFreeze() {
|
arrangeConfiguredStructuredValue("DATE", "2026-09-07", null,
|
java.sql.Date.valueOf("2026-09-07"));
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(result.getDiagnostics().toString(), RecordFreezeCheckResult.READY, result.getStatus());
|
}
|
|
@Test
|
public void blocksAllDriftedCrossTemplateSnapshotsWithoutWritingTargetValues() {
|
arrangeRecord("item-1", "expected", "expected", 0, "SUCCESS", "PRIMARY", "field-1");
|
ElnCrossTemplateSnapshotResolver.SnapshotIssue first =
|
new ElnCrossTemplateSnapshotResolver.SnapshotIssue("SOURCE_VALUE_DRIFT",
|
"源字段值已变化", "binding-1", "field-1", "SOURCE-A");
|
ElnCrossTemplateSnapshotResolver.SnapshotIssue second =
|
new ElnCrossTemplateSnapshotResolver.SnapshotIssue("SOURCE_REVISION_DRIFT",
|
"源记录当前修订已变化", "binding-2", "field-2", "SOURCE-B");
|
when(crossTemplateSnapshotResolver.validatePersistedSnapshots(
|
eq("tenant-1"), eq("item-1"), any()))
|
.thenReturn(Arrays.asList(first, second));
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertEquals(2, result.getDiagnostics().stream()
|
.filter(issue -> "CROSS_TEMPLATE".equals(issue.getCategory())).count());
|
assertTrue(result.getDiagnostics().stream().anyMatch(issue -> "binding-1".equals(issue.getTargetBindingId())
|
&& "field-1".equals(issue.getTargetFieldCode())
|
&& "SOURCE-A".equals(issue.getSourceTemplateCode())));
|
verify(valueMapper, never()).updateById(any(ElnRecordFieldValueEntity.class));
|
}
|
|
@Test
|
public void permitsNonRequiredMissingFormulaInputButBlocksRecalculatedDocxMismatch() {
|
arrangeRecord("item-1", "expected", "expected", 0, "MISSING_INPUT", "PRIMARY", "field-1");
|
when(calculation.recalculateAll(anyString(), any(), any(), any(), anyString(), anyString())).thenReturn(Collections.emptyList());
|
RecordFreezeCheckResult ready = service.prepare(request("item-1")).getItems().get(0);
|
assertEquals(ready.getDiagnostics().toString(), RecordFreezeCheckResult.READY, ready.getStatus());
|
assertFalse(ready.getDiagnostics().get(0).isBlocking());
|
|
arrangeRecord("item-1", "old", "different", 0, "SUCCESS", "PRIMARY", "field-1");
|
RecordFreezeCheckResult blocked = service.prepare(request("item-1")).getItems().get(0);
|
assertEquals(RecordFreezeCheckResult.BLOCKED, blocked.getStatus());
|
}
|
|
@Test
|
public void blocksFormulaWhenItsActiveResultBindingOrCurrentValueIsMissing() {
|
arrangeRecord("item-1", "expected", "expected", 0, "SUCCESS", "PRIMARY", "field-1");
|
ElnTemplateFormulaBindingEntity formula = new ElnTemplateFormulaBindingEntity();
|
formula.setId("formula-1");
|
formula.setMubanId("template-1");
|
formula.setBangdingZhuangtai("ACTIVE");
|
formula.setJieguoBangdingId("missing-result-binding");
|
when(formulaBindingMapper.selectList(any())).thenReturn(Collections.singletonList(formula));
|
when(calculation.recalculateAll(anyString(), any(), any(), any(), anyString(), anyString())).thenReturn(Collections.emptyList());
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().stream().anyMatch(issue -> "FORMULA".equals(issue.getCategory())
|
&& issue.getCode().equals("FORMULA_RESULT_BINDING_INVALID")));
|
}
|
|
@Test
|
public void blocksRequiredRepeatFormulaWhenAnActiveRowIsMissingInput() {
|
ElnRecordRepeatValueEntity repeatValue = repeatFormulaValue("MISSING_INPUT", null);
|
repeatValue.setJisuanZhuangtai("MISSING_INPUT");
|
ElnRecordFormulaCalculationResult calculationResult =
|
new ElnRecordFormulaCalculationResult();
|
calculationResult.setRepeatRows(Collections.singletonList(repeatRow()));
|
calculationResult.setRepeatValues(Collections.singletonList(repeatValue));
|
arrangeRequiredRepeatFormula(calculationResult, "");
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().stream().anyMatch(issue ->
|
"REQUIRED_REPEAT_FORMULA_NOT_SUCCESS".equals(issue.getCode())));
|
}
|
|
@Test
|
public void blocksWhenRequiredRepeatFormulaCellIsMissingForActiveRow() {
|
ElnRecordFormulaCalculationResult calculationResult =
|
new ElnRecordFormulaCalculationResult();
|
calculationResult.setRepeatRows(Collections.singletonList(repeatRow()));
|
arrangeRequiredRepeatFormula(calculationResult, "");
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().stream().anyMatch(issue ->
|
"REPEAT_FORMULA_RESULT_MISSING".equals(issue.getCode())));
|
}
|
|
@Test
|
public void blocksWhenRecalculatedRepeatFormulaDiffersFromDocx() {
|
ElnRecordFormulaCalculationResult calculationResult =
|
new ElnRecordFormulaCalculationResult();
|
calculationResult.setRepeatRows(Collections.singletonList(repeatRow()));
|
calculationResult.setRepeatValues(Collections.singletonList(
|
repeatFormulaValue("SUCCESS", "expected")));
|
arrangeRequiredRepeatFormula(calculationResult, "tampered");
|
|
RecordFreezeCheckResult result = service.prepare(request("item-1")).getItems().get(0);
|
|
assertEquals(RecordFreezeCheckResult.BLOCKED, result.getStatus());
|
assertTrue(result.getDiagnostics().stream().anyMatch(issue ->
|
"DOCX_REPEAT_FORMULA_VALUE_MISMATCH".equals(issue.getCode())));
|
}
|
|
private void arrangeRequiredRepeatFormula(
|
ElnRecordFormulaCalculationResult calculationResult, String runtimeDocxValue) {
|
arrangeRecord("item-1", "expected", "expected", 0,
|
"SUCCESS", "PRIMARY", "field-1");
|
ElnTemplateBindingEntity repeatResult = binding("repeat-result", "REPEAT",
|
"eln.repeat.group-a.prototype.repeat-result", "repeat-result");
|
repeatResult.setRepeatGroupCode("group-a");
|
repeatResult.setZiduanBanbenId("repeat-version");
|
ElnTemplateBindingEntity testResult = binding("binding-result", "PRIMARY",
|
"eln.field.test.result", ElnTestResultFields.RESULT);
|
testResult.setZiduanBanbenId("version-result");
|
ElnTemplateBindingEntity conclusion = binding("binding-conclusion", "PRIMARY",
|
"eln.field.test.conclusion", ElnTestResultFields.CONCLUSION);
|
conclusion.setZiduanBanbenId("version-conclusion");
|
when(bindingMapper.selectList(any())).thenReturn(Arrays.asList(
|
binding("binding-1", "PRIMARY", "eln.field.field", "field-1"),
|
testResult, conclusion, repeatResult));
|
when(formulaBindingMapper.selectList(any())).thenReturn(Collections.singletonList(
|
formula("repeat-formula", "repeat-result")));
|
when(versionMapper.selectById(anyString())).thenAnswer(invocation -> {
|
String id = invocation.getArgument(0);
|
if ("repeat-version".equals(id)) return fieldVersion(id, "TEXT", 1);
|
if ("version-result".equals(id)) return fieldVersion(id, "TEXTAREA", 1);
|
if ("version-conclusion".equals(id)) return fieldVersion(id, "SELECT", 1);
|
return fieldVersion(id, "TEXT", 0);
|
});
|
when(evidence.readControls("tenant-1", "record.docx")).thenReturn(Arrays.asList(
|
new DocxControlSnapshot("eln.field.field", "", "", "TEXT", "PRIMARY",
|
"word/document.xml", "", Collections.emptyMap(), "expected"),
|
new DocxControlSnapshot("eln.field.test.result", "", "", "TEXTAREA",
|
"PRIMARY", "word/document.xml", "", Collections.emptyMap(), "ELN 检验结果"),
|
new DocxControlSnapshot("eln.field.test.conclusion", "", "", "SELECT",
|
"PRIMARY", "word/document.xml", "", Collections.emptyMap(), "compliant"),
|
new DocxControlSnapshot("eln.repeat.group-a.prototype.repeat-result", "", "",
|
"TEXT", "REPEAT", "word/document.xml", "", Collections.emptyMap(), ""),
|
new DocxControlSnapshot("eln.repeat.group-a.row-1.repeat-result", "", "",
|
"TEXT", "REPEAT", "word/document.xml", "", Collections.emptyMap(),
|
runtimeDocxValue)));
|
when(calculation.recalculateAllWithRepeats(anyString(), any(), any(), any(),
|
anyString(), anyString())).thenReturn(calculationResult);
|
when(repeatValueMapper.updateById(any(ElnRecordRepeatValueEntity.class))).thenReturn(1);
|
}
|
|
private static ElnRecordRepeatRowEntity repeatRow() {
|
ElnRecordRepeatRowEntity row = new ElnRecordRepeatRowEntity();
|
row.setRepeatGroupCode("group-a");
|
row.setRowId("row-1");
|
row.setOperationStatus("ACTIVE");
|
row.setFDeleteMark(0);
|
return row;
|
}
|
|
private static ElnRecordRepeatValueEntity repeatFormulaValue(String status, String text) {
|
ElnRecordRepeatValueEntity value = new ElnRecordRepeatValueEntity();
|
value.setRepeatGroupCode("group-a");
|
value.setRepeatRowId("row-1");
|
value.setMubanBangdingId("repeat-result");
|
value.setZiduanBanbenId("repeat-version");
|
value.setZiduanBianma("repeat-result");
|
value.setZhiWenben(text);
|
value.setJisuanZhuangtai(status);
|
return value;
|
}
|
|
private void arrangeRecord(String itemId, String storedValue, String docxValue, int required,
|
String formulaStatus, String controlRole, String fieldCode) {
|
ElnRecordEntity record = new ElnRecordEntity();
|
record.setId("record-1"); record.setJianyanXiangId(itemId); record.setDangqianXiudingId("revision-1");
|
record.setMubanId("template-1"); record.setFVersion(1);
|
ElnRecordRevisionEntity revision = new ElnRecordRevisionEntity();
|
revision.setId("revision-1"); revision.setDianziJiluId("record-1"); revision.setBizStatus("DRAFT"); revision.setJiluWendang("record.docx");
|
ElnRecordFieldValueEntity value = new ElnRecordFieldValueEntity();
|
value.setMubanBangdingId("binding-1"); value.setZiduanBanbenId("version-1"); value.setZiduanBianma(fieldCode);
|
value.setZhiWenben(storedValue); value.setJisuanZhuangtai(formulaStatus);
|
ElnRecordFieldValueEntity testResult = value("binding-result", "version-result",
|
ElnTestResultFields.RESULT, "ELN 检验结果");
|
ElnRecordFieldValueEntity testConclusion = value("binding-conclusion", "version-conclusion",
|
ElnTestResultFields.CONCLUSION, "compliant");
|
ElnFieldVersionEntity version = new ElnFieldVersionEntity();
|
version.setId("version-1"); version.setFTenantId("tenant-1"); version.setShujuLeixing("TEXT"); version.setShifouBitian(required);
|
when(recordMapper.selectLiveByTestWorkItem("tenant-1", itemId)).thenReturn(record);
|
when(recordMapper.selectLiveForUpdate("tenant-1", "record-1")).thenReturn(record);
|
when(revisionMapper.selectOne(any())).thenReturn(revision);
|
when(valueMapper.selectList(any())).thenReturn(Arrays.asList(value, testResult, testConclusion));
|
when(operationMapper.selectCount(any())).thenReturn(0L);
|
ElnTemplateBindingEntity resultBinding = binding("binding-result", "PRIMARY",
|
"eln.field.test.result", ElnTestResultFields.RESULT);
|
resultBinding.setZiduanBanbenId("version-result");
|
ElnTemplateBindingEntity conclusionBinding = binding("binding-conclusion", "PRIMARY",
|
"eln.field.test.conclusion", ElnTestResultFields.CONCLUSION);
|
conclusionBinding.setZiduanBanbenId("version-conclusion");
|
when(bindingMapper.selectList(any())).thenReturn(Arrays.asList(
|
binding("binding-1", "PRIMARY", "eln.field.field", fieldCode), resultBinding, conclusionBinding));
|
when(formulaBindingMapper.selectList(any())).thenReturn(Collections.singletonList(
|
formula("formula-1", "binding-1")));
|
when(versionMapper.selectById(anyString())).thenAnswer(invocation -> {
|
String id = invocation.getArgument(0);
|
if ("version-result".equals(id)) return fieldVersion(id, "TEXTAREA", 1);
|
if ("version-conclusion".equals(id)) return fieldVersion(id, "SELECT", 1);
|
return version;
|
});
|
when(evidence.readControls("tenant-1", "record.docx")).thenReturn(Arrays.asList(
|
new DocxControlSnapshot("eln.field.field", "", "", "TEXT", controlRole, "word/document.xml", "", Collections.emptyMap(), docxValue),
|
new DocxControlSnapshot("eln.field.test.result", "", "", "TEXTAREA", "PRIMARY", "word/document.xml", "", Collections.emptyMap(), "ELN 检验结果"),
|
new DocxControlSnapshot("eln.field.test.conclusion", "", "", "SELECT", "PRIMARY", "word/document.xml", "", Collections.emptyMap(), "compliant")));
|
when(recordMapper.advanceVersion("tenant-1", "record-1", 1, "user-1")).thenReturn(1);
|
when(valueMapper.updateById(any(ElnRecordFieldValueEntity.class))).thenReturn(1);
|
when(fence.acquireForOperation(anyString(), anyString(), anyString(), anyString(), anyString())).thenAnswer(invocation -> response("freeze:" + invocation.getArgument(4)));
|
when(fence.release(anyString(), anyString(), anyString(), anyString(), anyString())).thenReturn(response(true));
|
}
|
|
private void arrangeConfiguredStructuredValue(String type, String docxValue,
|
BigDecimal number, Date date) {
|
arrangeRecord("item-1", null, docxValue, 1, "SUCCESS", "PRIMARY", "field-1");
|
ElnRecordFieldValueEntity value = valueMapper.selectList(null).get(0);
|
value.setZhiShuzhi(number);
|
value.setZhiRiqi(date);
|
value.setZhiLaiyuan("LIMS_TASK");
|
value.setYuanShuxing("configured.value");
|
value.setYuanShuxingBanben(1);
|
value.setYuanQuzhiZhuangtai("SUCCESS");
|
value.setYuanXueyuan("configured.dataset@1/value");
|
value.setYuanHuoquShijian(java.sql.Timestamp.valueOf("2026-09-07 10:00:00"));
|
when(versionMapper.selectById(anyString())).thenAnswer(invocation -> {
|
String id = invocation.getArgument(0);
|
ElnFieldVersionEntity version = fieldVersion(id,
|
"version-result".equals(id) ? "TEXTAREA"
|
: "version-conclusion".equals(id) ? "SELECT" : type,
|
1);
|
if ("version-1".equals(id)) {
|
version.setBangdingPeizhi("{\"read\":{\"source\":\"LIMS_TASK\","
|
+ "\"property\":\"configured.value\",\"propertyRevision\":1}}");
|
}
|
return version;
|
});
|
when(calculation.recalculateAll(anyString(), any(), any(), any(), anyString(), anyString()))
|
.thenReturn(Collections.emptyList());
|
}
|
|
private static ElnTemplateBindingEntity binding(String id, String role, String tag, String code) {
|
ElnTemplateBindingEntity binding = new ElnTemplateBindingEntity();
|
binding.setId(id); binding.setMubanId("template-1"); binding.setBangdingZhuangtai("ACTIVE");
|
binding.setKongjianJuese(role); binding.setKongjianBiaoqian(tag); binding.setKongjianLeixing(
|
ElnTestResultFields.RESULT.equals(code) ? "TEXTAREA"
|
: ElnTestResultFields.CONCLUSION.equals(code) ? "SELECT" : "TEXT");
|
binding.setZiduanDingyiId("definition-1"); binding.setZiduanBanbenId("version-1"); binding.setZiduanBianma(code);
|
return binding;
|
}
|
|
private static ElnRecordFieldValueEntity value(String bindingId, String versionId,
|
String code, String text) {
|
ElnRecordFieldValueEntity value = new ElnRecordFieldValueEntity();
|
value.setMubanBangdingId(bindingId);
|
value.setZiduanBanbenId(versionId);
|
value.setZiduanBianma(code);
|
value.setZhiWenben(text);
|
return value;
|
}
|
|
private static ElnFieldVersionEntity fieldVersion(String id, String type, int required) {
|
ElnFieldVersionEntity version = new ElnFieldVersionEntity();
|
version.setId(id);
|
version.setFTenantId("tenant-1");
|
version.setShujuLeixing(type);
|
version.setShifouBitian(required);
|
return version;
|
}
|
|
private static ElnTemplateFormulaBindingEntity formula(String id, String resultBindingId) {
|
ElnTemplateFormulaBindingEntity formula = new ElnTemplateFormulaBindingEntity();
|
formula.setId(id);
|
formula.setMubanId("template-1");
|
formula.setBangdingZhuangtai("ACTIVE");
|
formula.setJieguoBangdingId(resultBindingId);
|
return formula;
|
}
|
|
private static RecordFreezeCheckRequest request(String itemId) {
|
RecordFreezeCheckRequest request = new RecordFreezeCheckRequest();
|
request.setTenantId("tenant-1"); request.setUserId("user-1"); request.setOperationCode("op-1");
|
request.setTestWorkItemIds(Collections.singletonList(itemId));
|
return request;
|
}
|
|
private static boolean hasCategory(RecordFreezeCheckResult result, String category) {
|
return result.getDiagnostics().stream().anyMatch(issue -> category.equals(issue.getCategory()));
|
}
|
|
private static <T> ActionResult<T> response(T data) {
|
ActionResult<T> response = new ActionResult<>(); response.setCode(200); response.setData(data); return response;
|
}
|
}
|
