package jnpf.elnService.template;
|
|
import jnpf.elnEntity.field.ElnFieldDefEntity;
|
import jnpf.elnEntity.field.ElnFieldVersionEntity;
|
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
|
import jnpf.elnEntity.template.ElnTemplateVersionEntity;
|
import jnpf.elnEntity.template.ElnTemplateVos;
|
import jnpf.elnService.template.docx.DocxControlSnapshot;
|
import jnpf.elnService.template.impl.ElnTemplateHealthServiceImpl;
|
import jnpf.exception.DataException;
|
import org.junit.Test;
|
|
import java.lang.reflect.Constructor;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertFalse;
|
import static org.junit.Assert.assertNotNull;
|
import static org.junit.Assert.assertTrue;
|
import static org.junit.Assert.fail;
|
|
public class ElnTemplateHealthServiceImplTest {
|
|
@Test
|
public void reportsMissingRequiredTestResultBindings() {
|
Fixture fixture = new Fixture();
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertCode(report, "TEST_RESULT_BINDING_REQUIRED");
|
assertCode(report, "TEST_CONCLUSION_BINDING_REQUIRED");
|
assertEquals("ERROR", diagnostic(report,
|
"TEST_RESULT_BINDING_REQUIRED").getSeverity());
|
assertEquals("ERROR", diagnostic(report,
|
"TEST_CONCLUSION_BINDING_REQUIRED").getSeverity());
|
}
|
|
@Test
|
public void reportsSingleCheckboxGroupMemberWithDraftAndPublishedSeverity() {
|
Fixture draft = new Fixture();
|
draft.template.setBizStatus("DRAFT");
|
draft.checkboxBinding("passed", "result_choice", "step-a", false);
|
|
ElnTemplateHealthService.HealthDiagnostic warning = diagnostic(
|
draft.service.inspect("template-1"), "CHECKBOX_GROUP_SINGLE_MEMBER");
|
|
assertEquals("WARNING", warning.getSeverity());
|
assertEquals("result_choice", warning.getCheckboxGroupCode());
|
assertEquals(Collections.singletonList("passed"), warning.getBindingIds());
|
assertEquals("passed", warning.getBindingId());
|
assertEquals(Collections.singletonList("LOCATE"), warning.getActions());
|
assertTrue(warning.getMessage().contains("只有一个成员"));
|
|
Fixture published = new Fixture();
|
published.template.setBizStatus("PUBLISHED");
|
published.checkboxBinding("passed", "result_choice", "step-a", false);
|
assertEquals("ERROR", diagnostic(published.service.inspect("template-1"),
|
"CHECKBOX_GROUP_SINGLE_MEMBER").getSeverity());
|
}
|
|
@Test
|
public void acceptsValidCheckboxGroupAndRejectsScopeOrDefaultConflicts() {
|
Fixture valid = new Fixture();
|
valid.template.setBizStatus("DRAFT");
|
valid.checkboxBinding("passed", "result_choice", "step-a", true);
|
valid.checkboxBinding("failed", "result_choice", "step-a", false);
|
assertNoCode(valid.service.inspect("template-1"), "CHECKBOX_GROUP_SINGLE_MEMBER");
|
assertNoCode(valid.service.inspect("template-1"), "CHECKBOX_GROUP_SCOPE_MISMATCH");
|
assertNoCode(valid.service.inspect("template-1"),
|
"CHECKBOX_GROUP_DEFAULT_COUNT_OUT_OF_RANGE");
|
|
Fixture scope = new Fixture();
|
scope.template.setBizStatus("DRAFT");
|
scope.checkboxBinding("passed", "result_choice", "step-a", false);
|
scope.checkboxBinding("failed", "result_choice", "step-b", false);
|
ElnTemplateHealthService.HealthDiagnostic scopeError = diagnostic(
|
scope.service.inspect("template-1"), "CHECKBOX_GROUP_SCOPE_MISMATCH");
|
assertEquals(Arrays.asList("failed", "passed"), scopeError.getBindingIds());
|
assertTrue(scopeError.getMessage().contains("同一步骤"));
|
|
Fixture defaults = new Fixture();
|
defaults.template.setBizStatus("DRAFT");
|
defaults.checkboxBinding("passed", "result_choice", "step-a", true);
|
defaults.checkboxBinding("failed", "result_choice", "step-a", true);
|
ElnTemplateHealthService.HealthDiagnostic defaultError = diagnostic(
|
defaults.service.inspect("template-1"),
|
"CHECKBOX_GROUP_DEFAULT_COUNT_OUT_OF_RANGE");
|
assertEquals("ERROR", defaultError.getSeverity());
|
assertTrue(defaultError.getMessage().contains("默认勾选"));
|
}
|
|
@Test
|
public void reportsMissingAndOrphanSelectionGroupRules() {
|
Fixture missing = new Fixture();
|
missing.checkboxBinding("passed", "result_choice", "step-a", false);
|
missing.checkboxBinding("failed", "result_choice", "step-a", false);
|
missing.checkboxGroups.clear();
|
assertCode(missing.service.inspect("template-1"),
|
"CHECKBOX_GROUP_RULE_MISSING");
|
|
Fixture orphan = new Fixture();
|
orphan.configureCheckboxGroup("orphan", 0, 1);
|
assertCode(orphan.service.inspect("template-1"),
|
"CHECKBOX_GROUP_WITHOUT_MEMBER");
|
}
|
|
@Test
|
public void reportsInvalidBoundsAndMinimumAboveMemberCount() {
|
Fixture invalid = new Fixture();
|
invalid.checkboxBinding("passed", "result_choice", "step-a", false);
|
invalid.checkboxBinding("failed", "result_choice", "step-a", false);
|
invalid.configureCheckboxGroup("result_choice", 3, 2);
|
assertCode(invalid.service.inspect("template-1"),
|
"CHECKBOX_GROUP_RULE_INVALID");
|
|
Fixture tooFewMembers = new Fixture();
|
tooFewMembers.checkboxBinding("passed", "result_choice", "step-a", true);
|
tooFewMembers.checkboxBinding("failed", "result_choice", "step-a", false);
|
tooFewMembers.configureCheckboxGroup("result_choice", 3, null);
|
assertCode(tooFewMembers.service.inspect("template-1"),
|
"CHECKBOX_GROUP_MIN_EXCEEDS_MEMBERS");
|
}
|
|
@Test
|
public void validatesDefaultCheckedCountAgainstArbitraryRuleBounds() {
|
Fixture twoAllowed = new Fixture();
|
twoAllowed.checkboxBinding("passed", "result_choice", "step-a", true);
|
twoAllowed.checkboxBinding("failed", "result_choice", "step-a", true);
|
twoAllowed.configureCheckboxGroup("result_choice", 1, 2);
|
assertNoCode(twoAllowed.service.inspect("template-1"),
|
"CHECKBOX_GROUP_DEFAULT_COUNT_OUT_OF_RANGE");
|
|
Fixture minimumMissing = new Fixture();
|
minimumMissing.checkboxBinding("passed", "result_choice", "step-a", false);
|
minimumMissing.checkboxBinding("failed", "result_choice", "step-a", false);
|
minimumMissing.configureCheckboxGroup("result_choice", 1, null);
|
assertCode(minimumMissing.service.inspect("template-1"),
|
"CHECKBOX_GROUP_DEFAULT_COUNT_OUT_OF_RANGE");
|
}
|
|
@Test
|
public void reportsInvalidCheckboxGroupCodeMemberAndOwnershipWithoutNullFailure() {
|
Fixture fixture = new Fixture();
|
fixture.template.setBizStatus("DRAFT");
|
fixture.checkboxBinding("passed", "含中文", "step-a", false);
|
fixture.checkboxBinding("failed", "含中文", "step-a", false);
|
fixture.bindings.get(0).setKongjianLeixing("TEXT");
|
fixture.bindings.get(1).setZiduanBanbenId("missing-version");
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertCode(report, "CHECKBOX_GROUP_CODE_INVALID");
|
assertCode(report, "CHECKBOX_GROUP_MEMBER_INVALID");
|
}
|
|
@Test
|
public void rejectsMixedAndDifferentRepeatCheckboxGroupScopes() {
|
Fixture mixed = new Fixture();
|
mixed.checkboxBinding("primary", "result_choice", "step-a", false);
|
mixed.repeatCheckboxBinding("repeat", "result_choice", "samples", false);
|
assertCode(mixed.service.inspect("template-1"), "CHECKBOX_GROUP_SCOPE_MISMATCH");
|
|
Fixture differentRepeats = new Fixture();
|
differentRepeats.repeatCheckboxBinding("sample-result", "result_choice",
|
"samples", false);
|
differentRepeats.repeatCheckboxBinding("result-result", "result_choice",
|
"results", false);
|
assertCode(differentRepeats.service.inspect("template-1"),
|
"CHECKBOX_GROUP_SCOPE_MISMATCH");
|
}
|
|
@Test
|
public void doesNotReportCheckboxGroupDiagnosticsForUngroupedCheckboxes() {
|
Fixture fixture = new Fixture();
|
fixture.checkboxBinding("passed", null, "step-a", false);
|
fixture.checkboxBinding("failed", null, "step-a", false);
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertFalse(report.getDiagnostics().stream().anyMatch(item ->
|
item.getCode().startsWith("CHECKBOX_GROUP_")));
|
}
|
|
@Test
|
public void downloadsOnceReconcilesThenReportsAllAuthoritativeDiagnostics() {
|
Fixture fixture = new Fixture();
|
fixture.template.setBizStatus("DRAFT");
|
fixture.addStandardCases();
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertEquals("template-1", report.getTemplateId());
|
assertEquals("template-1.docx", report.getFileId());
|
assertEquals(1, fixture.downloads);
|
assertEquals(1, fixture.reconciliations);
|
assertEquals(1, fixture.bindingReads);
|
for (String code : Arrays.asList("ORPHAN_CONTROL", "MISSING_CONTROL", "DUPLICATE_TAG",
|
"ROLE_MISMATCH", "TYPE_MISMATCH", "CONFIG_MISMATCH",
|
"REFERENCE_WITHOUT_PRIMARY", "FIELD_VERSION_MISMATCH", "FIELD_DISABLED",
|
"FIELD_VERSION_NOT_PUBLISHED",
|
"PENDING_BINDING", "PENDING_CONFIRMATION_REQUIRED")) {
|
assertCode(report, code);
|
}
|
ElnTemplateHealthService.HealthDiagnostic missing = diagnostic(report, "MISSING_CONTROL");
|
assertEquals("missing", missing.getBindingId());
|
assertEquals("缺失字段", missing.getFieldDisplayName());
|
assertEquals(Arrays.asList("REPAIR", "CONFIRM_REMOVE"), missing.getActions());
|
assertEquals(Collections.singletonList("LOCATE"),
|
diagnostic(report, "ORPHAN_CONTROL").getActions());
|
ElnTemplateHealthService.HealthDiagnostic duplicate = diagnostic(report, "DUPLICATE_TAG");
|
assertEquals("duplicate", duplicate.getBindingId());
|
assertEquals("重复字段", duplicate.getFieldDisplayName());
|
assertEquals("word/header1.xml", diagnostic(report, "ORPHAN_CONTROL").getPartName());
|
assertFalse(report.getDiagnostics().stream()
|
.anyMatch(item -> "cancelled".equals(item.getBindingId())));
|
}
|
|
@Test
|
public void publishedTemplateCheckDoesNotReconcileAndOnlyReturnsLocateActions() {
|
Fixture fixture = new Fixture();
|
fixture.template.setBizStatus("PUBLISHED");
|
fixture.addStandardCases();
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertEquals(1, fixture.downloads);
|
assertEquals(0, fixture.reconciliations);
|
assertEquals(1, fixture.bindingReads);
|
assertTrue(diagnostic(report, "MISSING_CONTROL").getActions().isEmpty());
|
assertEquals(Collections.singletonList("LOCATE"),
|
diagnostic(report, "ORPHAN_CONTROL").getActions());
|
assertEquals(Collections.singletonList("LOCATE"),
|
diagnostic(report, "ROLE_MISMATCH").getActions());
|
assertTrue(report.getDiagnostics().stream().allMatch(item ->
|
item.getActions().isEmpty() || Collections.singletonList("LOCATE").equals(item.getActions())));
|
}
|
|
@Test
|
public void failsClosedForAnotherTenantTemplate() {
|
Fixture fixture = new Fixture();
|
fixture.template.setFTenantId("tenant-b");
|
|
try {
|
fixture.service.inspect("template-1");
|
fail("预期拒绝跨租户模板");
|
} catch (DataException expected) {
|
assertFalse(expected.getMessage().isEmpty());
|
}
|
assertEquals(0, fixture.downloads);
|
}
|
|
@Test
|
public void ignoresUnobservableTextConfigAndCanonicalizesDropdownOptions() {
|
Fixture fixture = new Fixture();
|
fixture.field("text-field", "enabled", "text-version");
|
fixture.version("text-version", "text-field", "PUBLISHED", "文本字段",
|
"{\"placeholder\":\"请输入\",\"defaultValue\":\"默认文本\"}");
|
fixture.binding("text", "text-field", "text-version", "eln.field.text",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
fixture.control("eln.field.text", "TEXT", "PRIMARY",
|
Collections.emptyMap(), "word/document.xml");
|
|
fixture.field("dropdown-field", "enabled", "dropdown-version");
|
fixture.version("dropdown-version", "dropdown-field", "PUBLISHED", "下拉字段",
|
dropdownConfigJson("不合格"));
|
fixture.binding("dropdown", "dropdown-field", "dropdown-version",
|
"eln.field.dropdown", "DROPDOWN", "PRIMARY", null, "ACTIVE");
|
Map<String, Object> reordered = new LinkedHashMap<>();
|
reordered.put("FAIL", "不合格");
|
reordered.put("PASS", "合格");
|
fixture.control("eln.field.dropdown", "DROPDOWN", "PRIMARY",
|
reordered, "word/document.xml");
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertNoDiagnostic(report, "CONFIG_MISMATCH", "text");
|
assertNoDiagnostic(report, "CONFIG_MISMATCH", "dropdown");
|
}
|
|
@Test
|
public void reportsObservableDropdownOptionDifference() {
|
Fixture fixture = new Fixture();
|
fixture.field("dropdown-field", "enabled", "dropdown-version");
|
fixture.version("dropdown-version", "dropdown-field", "PUBLISHED", "下拉字段",
|
dropdownConfigJson("不合格"));
|
fixture.binding("dropdown", "dropdown-field", "dropdown-version",
|
"eln.field.dropdown", "DROPDOWN", "PRIMARY", null, "ACTIVE");
|
Map<String, Object> different = new LinkedHashMap<>();
|
different.put("PASS", "合格");
|
different.put("FAIL", "异常");
|
fixture.control("eln.field.dropdown", "DROPDOWN", "PRIMARY",
|
different, "word/document.xml");
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertDiagnostic(report, "CONFIG_MISMATCH", "dropdown");
|
}
|
|
@Test
|
public void missingControlReturnsExpectedVersionAndEmptyDependencies() {
|
Fixture fixture = new Fixture();
|
fixture.field("missing-field", "enabled", "missing-version");
|
fixture.version("missing-version", "missing-field", "PUBLISHED", "缺失字段", null);
|
fixture.binding("missing", "missing-field", "missing-version", "eln.field.missing",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
fixture.bindings.get(0).setFVersion(7);
|
|
ElnTemplateHealthService.HealthDiagnostic missing = diagnostic(
|
fixture.service.inspect("template-1"), "MISSING_CONTROL");
|
|
assertEquals(Integer.valueOf(7), missing.getExpectedVersion());
|
assertNotNull(missing.getDependencies());
|
assertTrue(missing.getDependencies().isEmpty());
|
}
|
|
@Test
|
public void missingPrimaryMergesActiveReferenceAndValidatorDependencies() {
|
Fixture fixture = new Fixture();
|
fixture.field("field-1", "enabled", "version-1");
|
fixture.version("version-1", "field-1", "PUBLISHED", "样品编号", null);
|
fixture.binding("primary", "field-1", "version-1", "eln.field.sample_id",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
fixture.bindings.get(0).setFVersion(9);
|
fixture.binding("reference", "field-1", "version-1", "eln.ref.sample_id.01",
|
"TEXT", "REFERENCE", "primary", "ACTIVE");
|
fixture.control("eln.ref.sample_id.01", "TEXT", "REFERENCE",
|
Collections.emptyMap(), "word/document.xml");
|
ElnTemplateVos.Diagnostic formula = new ElnTemplateVos.Diagnostic();
|
formula.setSeverity("ERROR");
|
formula.setCode("FORMULA_DEPENDENCY");
|
formula.setMessage("公式仍引用该字段");
|
fixture.validatorDiagnostics = Collections.singletonList(formula);
|
|
ElnTemplateHealthService.HealthDiagnostic missing = diagnostic(
|
fixture.service.inspect("template-1"), "MISSING_CONTROL");
|
|
assertEquals(Integer.valueOf(9), missing.getExpectedVersion());
|
assertTrue(missing.getDependencies().stream().anyMatch(item ->
|
"ACTIVE_REFERENCE_DEPENDENCY".equals(item.getCode())
|
&& "reference".equals(item.getBindingId())));
|
assertTrue(missing.getDependencies().stream().anyMatch(item ->
|
"FORMULA_DEPENDENCY".equals(item.getCode())));
|
assertEquals(Collections.singleton("primary"), fixture.validatedRemovalIds);
|
}
|
|
@Test
|
public void acceptsSingleRepeatPrototypeGroupWhenAllColumnsShareOnePhysicalRow() {
|
Fixture fixture = new Fixture();
|
fixture.repeatBinding("repeat-result", "result", "version-result");
|
fixture.repeatControl("eln.repeat.samples.prototype.result", 0, 2, false, false);
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertFalse(report.getDiagnostics().stream().anyMatch(item ->
|
item.getCode().startsWith("REPEAT_")
|
|| item.getCode().startsWith("MULTIPLE_REPEAT_")));
|
}
|
|
@Test
|
public void rejectsNestedMergedOrSplitRepeatPrototypeRows() {
|
Fixture fixture = new Fixture();
|
fixture.repeatBinding("repeat-result", "result", "version-result");
|
fixture.repeatBinding("repeat-unit", "unit", "version-unit");
|
fixture.repeatControl("eln.repeat.samples.prototype.result", 0, 2, true, true);
|
fixture.repeatControl("eln.repeat.samples.prototype.unit", 0, 3, false, false);
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertCode(report, "NESTED_REPEAT_TABLE");
|
assertCode(report, "REPEAT_VERTICAL_MERGE");
|
assertCode(report, "MULTIPLE_REPEAT_PROTOTYPE_ROWS");
|
}
|
|
@Test
|
public void rejectsNestedContentControlsEvenWhenBindingMatches() {
|
Fixture fixture = new Fixture();
|
fixture.field("nested-field", "enabled", "nested-version");
|
fixture.version("nested-version", "nested-field", "PUBLISHED", "嵌套字段", null);
|
fixture.binding("nested", "nested-field", "nested-version", "eln.field.nested",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
fixture.nestedControl("eln.field.nested", "TEXT", "PRIMARY");
|
|
ElnTemplateHealthService.HealthDiagnostic diagnostic = diagnostic(
|
fixture.service.inspect("template-1"), "NESTED_CONTENT_CONTROL");
|
|
assertEquals("nested", diagnostic.getBindingId());
|
assertEquals("ERROR", diagnostic.getSeverity());
|
}
|
|
@Test
|
public void acceptsIndependentRepeatGroupsOnDifferentRows() {
|
Fixture fixture = new Fixture();
|
fixture.repeatBinding("repeat-result", "result", "version-result");
|
fixture.repeatBinding("repeat-sample", "sample", "version-sample");
|
ElnTemplateBindingEntity second = fixture.bindings.get(1);
|
second.setRepeatGroupCode("results");
|
second.setKongjianBiaoqian("eln.repeat.results.prototype.sample");
|
fixture.configureGroup("results");
|
fixture.repeatControl("eln.repeat.samples.prototype.result", 0, 2, false, false);
|
fixture.repeatControl("eln.repeat.results.prototype.sample", 0, 5, false, false);
|
|
ElnTemplateHealthService.HealthReport report = fixture.service.inspect("template-1");
|
|
assertFalse(report.getDiagnostics().stream().anyMatch(item ->
|
"MULTIPLE_REPEAT_GROUPS".equals(item.getCode())
|
|| "OVERLAPPING_REPEAT_GROUPS".equals(item.getCode())));
|
}
|
|
@Test
|
public void rejectsIndependentRepeatGroupsOnSamePhysicalRow() {
|
Fixture fixture = new Fixture();
|
fixture.repeatBinding("repeat-result", "result", "version-result");
|
fixture.repeatBinding("repeat-sample", "sample", "version-sample");
|
ElnTemplateBindingEntity second = fixture.bindings.get(1);
|
second.setRepeatGroupCode("results");
|
second.setKongjianBiaoqian("eln.repeat.results.prototype.sample");
|
fixture.configureGroup("results");
|
fixture.repeatControl("eln.repeat.samples.prototype.result", 0, 2, false, false);
|
fixture.repeatControl("eln.repeat.results.prototype.sample", 0, 2, false, false);
|
|
assertCode(fixture.service.inspect("template-1"), "OVERLAPPING_REPEAT_GROUPS");
|
}
|
|
@Test
|
public void rejectsRepeatBindingsWithoutGroupConfiguration() {
|
Fixture fixture = new Fixture();
|
fixture.repeatBinding("repeat-result", "result", "version-result");
|
fixture.repeatControl("eln.repeat.samples.prototype.result", 0, 2, false, false);
|
fixture.repeatGroups.clear();
|
|
assertCode(fixture.service.inspect("template-1"), "REPEAT_GROUP_CONFIG_MISSING");
|
}
|
|
private static void assertCode(ElnTemplateHealthService.HealthReport report, String code) {
|
diagnostic(report, code);
|
}
|
|
private static void assertNoCode(ElnTemplateHealthService.HealthReport report, String code) {
|
assertFalse("不应存在诊断: " + code,
|
report.getDiagnostics().stream().anyMatch(item -> code.equals(item.getCode())));
|
}
|
|
private static ElnTemplateHealthService.HealthDiagnostic diagnostic(
|
ElnTemplateHealthService.HealthReport report, String code) {
|
return report.getDiagnostics().stream().filter(item -> code.equals(item.getCode()))
|
.findFirst().orElseThrow(() -> new AssertionError("缺少诊断: " + code));
|
}
|
|
private static void assertDiagnostic(ElnTemplateHealthService.HealthReport report,
|
String code, String bindingId) {
|
assertTrue("缺少诊断: " + code + "/" + bindingId,
|
report.getDiagnostics().stream().anyMatch(item -> code.equals(item.getCode())
|
&& bindingId.equals(item.getBindingId())));
|
}
|
|
private static void assertNoDiagnostic(ElnTemplateHealthService.HealthReport report,
|
String code, String bindingId) {
|
assertFalse("不应存在诊断: " + code + "/" + bindingId,
|
report.getDiagnostics().stream().anyMatch(item -> code.equals(item.getCode())
|
&& bindingId.equals(item.getBindingId())));
|
}
|
|
private static String dropdownConfigJson(String failedDisplay) {
|
return "{\"controlType\":\"dropdown\",\"placeholder\":\"请选择\","
|
+ "\"defaultOptionValue\":\"PASS\",\"options\":["
|
+ "{\"display\":\"合格\",\"value\":\"PASS\"},"
|
+ "{\"display\":\"" + failedDisplay + "\",\"value\":\"FAIL\"}]}";
|
}
|
|
private static final class Fixture implements ElnTemplateHealthServiceImpl.Store {
|
private final ElnTemplateVersionEntity template = new ElnTemplateVersionEntity();
|
private final Map<String, ElnFieldDefEntity> fields = new LinkedHashMap<>();
|
private final Map<String, ElnFieldVersionEntity> versions = new LinkedHashMap<>();
|
private final List<ElnTemplateBindingEntity> bindings = new ArrayList<>();
|
private final List<DocxControlSnapshot> controls = new ArrayList<>();
|
private final List<ElnTemplateVos.RepeatGroup> repeatGroups = new ArrayList<>();
|
private final List<ElnTemplateVos.CheckboxGroup> checkboxGroups =
|
new ArrayList<>();
|
private int downloads;
|
private int reconciliations;
|
private int bindingReads;
|
private List<ElnTemplateVos.Diagnostic> validatorDiagnostics = Collections.emptyList();
|
private Set<String> validatedRemovalIds = Collections.emptySet();
|
private final ElnTemplateHealthService service;
|
|
private Fixture() {
|
template.setId("template-1");
|
template.setFTenantId("tenant-a");
|
template.setMubanFile("[{\"fileId\":\"template-1.docx\",\"fileExtension\":\"docx\"}]");
|
template.setFDeleteMark(0);
|
ElnTemplateDocumentEvidence evidence = (tenant, file) -> {
|
downloads++;
|
assertEquals("tenant-a", tenant);
|
assertEquals("template-1.docx", file);
|
return new ArrayList<>(controls);
|
};
|
ElnTemplateHealthServiceImpl.PendingReconciler reconciler =
|
(tenant, templateId, now, snapshots) -> {
|
reconciliations++;
|
ElnTemplateVos.Diagnostic item = new ElnTemplateVos.Diagnostic();
|
item.setSeverity("WARNING");
|
item.setCode("PENDING_CONFIRMATION_REQUIRED");
|
item.setBindingId("pending");
|
item.setControlTag("eln.field.pending");
|
item.setMessage("需要确认");
|
return Collections.singletonList(item);
|
};
|
ElnTemplateBindingDependencyValidator validator =
|
new ElnTemplateBindingDependencyValidator() {
|
@Override
|
public List<ElnTemplateVos.Diagnostic> validateUpgrade(String tenantId,
|
String templateId, Set<String> bindingIds,
|
String targetFieldVersionId) {
|
return Collections.emptyList();
|
}
|
|
@Override
|
public List<ElnTemplateVos.Diagnostic> validateRemoval(String tenantId,
|
String templateId, Set<String> bindingIds) {
|
validatedRemovalIds = bindingIds;
|
return validatorDiagnostics;
|
}
|
|
@Override
|
public List<ElnTemplateVos.Diagnostic> validatePromotion(String tenantId,
|
String templateId, String primaryBindingId,
|
String referenceBindingId) {
|
return Collections.emptyList();
|
}
|
};
|
service = construct(this, evidence, reconciler, () -> "tenant-a",
|
Collections.singletonList(validator), (tenantId, templateId) ->
|
new ArrayList<>(repeatGroups), (tenantId, templateId) ->
|
new ArrayList<>(checkboxGroups));
|
}
|
|
private void addStandardCases() {
|
field("normal-field", "enabled", "normal-version");
|
version("normal-version", "normal-field", "PUBLISHED", "正常字段", null);
|
binding("normal", "normal-field", "normal-version", "eln.field.normal",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.normal", "TEXT", "PRIMARY", null, "word/document.xml");
|
|
field("missing-field", "enabled", "missing-version");
|
version("missing-version", "missing-field", "PUBLISHED", "缺失字段", null);
|
binding("missing", "missing-field", "missing-version", "eln.field.missing",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
|
field("dup-field", "enabled", "dup-version");
|
version("dup-version", "dup-field", "PUBLISHED", "重复字段", null);
|
binding("duplicate", "dup-field", "dup-version", "eln.field.duplicate",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.duplicate", "TEXT", "PRIMARY", null, "word/document.xml");
|
control("eln.field.duplicate", "TEXT", "PRIMARY", null, "word/footer1.xml");
|
|
field("role-field", "enabled", "role-version");
|
version("role-version", "role-field", "PUBLISHED", "角色字段", null);
|
binding("role", "role-field", "role-version", "eln.field.role",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.role", "TEXT", "REFERENCE", null, "word/document.xml");
|
|
field("type-field", "enabled", "type-version");
|
version("type-version", "type-field", "PUBLISHED", "类型字段", null);
|
binding("type", "type-field", "type-version", "eln.field.type",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.type", "DATE", "PRIMARY", null, "word/document.xml");
|
|
field("config-field", "enabled", "config-version");
|
version("config-version", "config-field", "PUBLISHED", "配置字段",
|
dropdownConfigJson("不合格"));
|
binding("config", "config-field", "config-version", "eln.field.config",
|
"DROPDOWN", "PRIMARY", null, "ACTIVE");
|
Map<String, Object> differentOptions = new LinkedHashMap<>();
|
differentOptions.put("PASS", "合格");
|
differentOptions.put("FAIL", "异常");
|
control("eln.field.config", "DROPDOWN", "PRIMARY",
|
differentOptions, "word/document.xml");
|
|
field("ref-field", "enabled", "ref-version");
|
version("ref-version", "ref-field", "PUBLISHED", "引用字段", null);
|
binding("reference", "ref-field", "ref-version", "eln.ref.reference.01",
|
"TEXT", "REFERENCE", "missing-primary", "ACTIVE");
|
control("eln.ref.reference.01", "TEXT", "REFERENCE", null, "word/document.xml");
|
|
field("version-field", "enabled", "wrong-owner-version");
|
version("wrong-owner-version", "another-field", "PUBLISHED", "错误版本", null);
|
binding("version-mismatch", "version-field", "wrong-owner-version",
|
"eln.field.version_mismatch", "TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.version_mismatch", "TEXT", "PRIMARY", null, "word/document.xml");
|
|
field("disabled-field", "disabled", "disabled-version");
|
version("disabled-version", "disabled-field", "PUBLISHED", "停用字段", null);
|
binding("disabled", "disabled-field", "disabled-version", "eln.field.disabled",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.disabled", "TEXT", "PRIMARY", null, "word/document.xml");
|
|
field("draft-field", "enabled", "draft-version");
|
version("draft-version", "draft-field", "DRAFT", "草稿字段", null);
|
binding("draft", "draft-field", "draft-version", "eln.field.draft",
|
"TEXT", "PRIMARY", null, "ACTIVE");
|
control("eln.field.draft", "TEXT", "PRIMARY", null, "word/document.xml");
|
|
field("pending-field", "enabled", "pending-version");
|
version("pending-version", "pending-field", "PUBLISHED", "待确认字段", null);
|
binding("pending", "pending-field", "pending-version", "eln.field.pending",
|
"TEXT", "PRIMARY", null, "PENDING");
|
control("eln.field.pending", "TEXT", "PRIMARY", null, "word/document.xml");
|
|
binding("cancelled", "normal-field", "normal-version", "eln.field.cancelled",
|
"TEXT", "PRIMARY", null, "CANCELLED");
|
control("eln.field.orphan", "TEXT", "PRIMARY", null, "word/header1.xml");
|
}
|
|
private void repeatBinding(String id, String fieldCode, String versionId) {
|
configureGroup("samples");
|
field(id + "-field", "enabled", versionId);
|
version(versionId, id + "-field", "PUBLISHED", fieldCode, null);
|
binding(id, id + "-field", versionId,
|
"eln.repeat.samples.prototype." + fieldCode,
|
"TEXT", "REPEAT", null, "ACTIVE");
|
ElnTemplateBindingEntity item = bindings.get(bindings.size() - 1);
|
item.setZiduanBianma(fieldCode);
|
item.setRepeatGroupCode("samples");
|
item.setRepeatPrototypeRowId("prototype");
|
}
|
|
private void checkboxBinding(String id, String groupCode, String stepId,
|
boolean defaultChecked) {
|
if (groupCode != null && checkboxGroups.stream().noneMatch(
|
item -> groupCode.equals(item.getGroupCode()))) {
|
configureCheckboxGroup(groupCode, 0, 1);
|
}
|
String fieldId = id + "-field";
|
String versionId = id + "-version";
|
field(fieldId, "enabled", versionId);
|
version(versionId, fieldId, "PUBLISHED", id,
|
"{\"defaultChecked\":" + defaultChecked + "}");
|
versions.get(versionId).setShujuLeixing("CHECKBOX");
|
binding(id, fieldId, versionId, "eln.field." + id,
|
"CHECKBOX", "PRIMARY", null, "ACTIVE");
|
ElnTemplateBindingEntity item = bindings.get(bindings.size() - 1);
|
item.setCheckboxGroupCode(groupCode);
|
item.setStepId(stepId);
|
control(item.getKongjianBiaoqian(), "CHECKBOX", "PRIMARY",
|
Collections.singletonMap("defaultChecked", defaultChecked),
|
"word/document.xml");
|
}
|
|
private void repeatCheckboxBinding(String id, String checkboxGroupCode,
|
String repeatGroupCode,
|
boolean defaultChecked) {
|
if (checkboxGroupCode != null && checkboxGroups.stream().noneMatch(
|
item -> checkboxGroupCode.equals(item.getGroupCode()))) {
|
configureCheckboxGroup(checkboxGroupCode, 0, 1);
|
}
|
configureGroup(repeatGroupCode);
|
String fieldId = id + "-field";
|
String versionId = id + "-version";
|
String tag = "eln.repeat." + repeatGroupCode + ".prototype." + id;
|
field(fieldId, "enabled", versionId);
|
version(versionId, fieldId, "PUBLISHED", id,
|
"{\"defaultChecked\":" + defaultChecked + "}");
|
versions.get(versionId).setShujuLeixing("CHECKBOX");
|
binding(id, fieldId, versionId, tag,
|
"CHECKBOX", "REPEAT", null, "ACTIVE");
|
ElnTemplateBindingEntity item = bindings.get(bindings.size() - 1);
|
item.setCheckboxGroupCode(checkboxGroupCode);
|
item.setRepeatGroupCode(repeatGroupCode);
|
item.setRepeatPrototypeRowId("prototype");
|
controls.add(new DocxControlSnapshot(tag, null, null,
|
"CHECKBOX", "REPEAT", "word/document.xml", "OK",
|
Collections.singletonMap("defaultChecked", defaultChecked),
|
null, 0, repeatGroups.size(), false, false));
|
}
|
|
private void configureGroup(String groupCode) {
|
if (repeatGroups.stream().anyMatch(item -> groupCode.equals(item.getGroupCode()))) {
|
return;
|
}
|
ElnTemplateVos.RepeatGroup group = new ElnTemplateVos.RepeatGroup();
|
group.setGroupCode(groupCode);
|
group.setMinRows(0);
|
group.setMaxRows(100);
|
repeatGroups.add(group);
|
}
|
|
private void configureCheckboxGroup(String groupCode, Integer minSelected,
|
Integer maxSelected) {
|
checkboxGroups.removeIf(item -> groupCode.equals(item.getGroupCode()));
|
ElnTemplateVos.CheckboxGroup group = new ElnTemplateVos.CheckboxGroup();
|
group.setGroupCode(groupCode);
|
group.setMinSelected(minSelected);
|
group.setMaxSelected(maxSelected);
|
group.setVersion(0);
|
checkboxGroups.add(group);
|
}
|
|
private void repeatControl(String tag, int tableIndex, int rowIndex,
|
boolean nested, boolean verticalMerge) {
|
controls.add(new DocxControlSnapshot(tag, null, null, "TEXT", "REPEAT",
|
"word/document.xml", "OK", Collections.emptyMap(), null,
|
tableIndex, rowIndex, nested, verticalMerge));
|
}
|
|
private void nestedControl(String tag, String type, String role) {
|
controls.add(new DocxControlSnapshot(tag, null, null, type, role,
|
"word/document.xml", "OK", Collections.emptyMap(), null,
|
null, null, false, false, true));
|
}
|
|
private void field(String id, String enabled, String currentVersion) {
|
ElnFieldDefEntity item = new ElnFieldDefEntity();
|
item.setId(id);
|
item.setFTenantId("tenant-a");
|
item.setBizEnabled(enabled);
|
item.setDangqianZiduanBanbenId(currentVersion);
|
fields.put(id, item);
|
}
|
|
private void version(String id, String fieldId, String status, String name, String config) {
|
ElnFieldVersionEntity item = new ElnFieldVersionEntity();
|
item.setId(id);
|
item.setFTenantId("tenant-a");
|
item.setZiduanDingyiId(fieldId);
|
item.setBizStatus(status);
|
item.setZiduanMingcheng(name);
|
item.setKongjianPeizhi(config);
|
versions.put(id, item);
|
}
|
|
private void binding(String id, String fieldId, String versionId, String tag,
|
String type, String role, String primaryId, String status) {
|
ElnTemplateBindingEntity item = new ElnTemplateBindingEntity();
|
item.setId(id);
|
item.setFTenantId("tenant-a");
|
item.setMubanId("template-1");
|
item.setZiduanDingyiId(fieldId);
|
item.setZiduanBanbenId(versionId);
|
item.setKongjianBiaoqian(tag);
|
item.setKongjianLeixing(type);
|
item.setKongjianJuese(role);
|
item.setYinyongShiliId(primaryId);
|
item.setBangdingZhuangtai(status);
|
bindings.add(item);
|
}
|
|
private void control(String tag, String type, String role, Map<String, Object> config,
|
String part) {
|
controls.add(new DocxControlSnapshot(tag, null, null, type, role, part, "OK", config));
|
}
|
|
@Override
|
public ElnTemplateVersionEntity findTemplate(String tenantId, String templateId) {
|
return tenantId.equals(template.getFTenantId()) && templateId.equals(template.getId())
|
? template : null;
|
}
|
|
@Override
|
public List<ElnTemplateBindingEntity> listBindings(String tenantId, String templateId) {
|
bindingReads++;
|
return new ArrayList<>(bindings);
|
}
|
|
@Override
|
public ElnFieldDefEntity findField(String tenantId, String fieldId) {
|
ElnFieldDefEntity item = fields.get(fieldId);
|
return item != null && tenantId.equals(item.getFTenantId()) ? item : null;
|
}
|
|
@Override
|
public ElnFieldVersionEntity findFieldVersion(String tenantId, String versionId) {
|
ElnFieldVersionEntity item = versions.get(versionId);
|
return item != null && tenantId.equals(item.getFTenantId()) ? item : null;
|
}
|
}
|
|
private static ElnTemplateHealthService construct(ElnTemplateHealthServiceImpl.Store store,
|
ElnTemplateDocumentEvidence evidence,
|
ElnTemplateHealthServiceImpl.PendingReconciler reconciler,
|
java.util.function.Supplier<String> tenantSupplier,
|
List<ElnTemplateBindingDependencyValidator> validators,
|
ElnTemplateHealthServiceImpl.RepeatGroupReader repeatGroupReader,
|
ElnTemplateHealthServiceImpl.CheckboxGroupReader checkboxGroupReader) {
|
try {
|
Constructor<ElnTemplateHealthServiceImpl> constructor =
|
ElnTemplateHealthServiceImpl.class.getDeclaredConstructor(
|
ElnTemplateHealthServiceImpl.Store.class,
|
ElnTemplateDocumentEvidence.class,
|
ElnTemplateHealthServiceImpl.PendingReconciler.class,
|
java.util.function.Supplier.class,
|
List.class,
|
ElnTemplateHealthServiceImpl.RepeatGroupReader.class,
|
ElnTemplateHealthServiceImpl.CheckboxGroupReader.class);
|
constructor.setAccessible(true);
|
return constructor.newInstance(store, evidence, reconciler, tenantSupplier,
|
validators, repeatGroupReader, checkboxGroupReader);
|
} catch (ReflectiveOperationException e) {
|
throw new AssertionError(e);
|
}
|
}
|
}
|
