package jnpf.limsService.provider;
|
|
import org.junit.Test;
|
import jnpf.exception.DataException;
|
|
import java.util.Collections;
|
import java.util.Arrays;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.OffsetDateTime;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertTrue;
|
import static org.junit.Assert.fail;
|
|
public class LimsElnSourceCatalogTest {
|
|
@Test
|
public void savesANewSourceDraftWithoutMakingItSelectable() {
|
LimsElnSourceCatalog catalog = catalog(newStore());
|
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(input("sample.original_batch"));
|
|
assertEquals("DRAFT", draft.getStatus());
|
assertEquals("sample.original_batch", catalog.detail(draft.getId()).getPropertyCode());
|
assertEquals("originalBatch", catalog.definition(draft.getId()).getFieldId());
|
assertTrue(catalog.catalog().isEmpty());
|
}
|
|
@Test
|
public void publishesOnlyAfterReadingAnAuthorizedSampleAndFreezesTheDefinition() {
|
LimsElnSourceCatalog catalog = new LimsElnSourceCatalog(newStore(),
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true),
|
(definition, actor, sampleId) -> {
|
assertEquals("work-item-a", sampleId);
|
assertEquals("originalBatch", definition.getFieldId());
|
return new LimsElnSourceCatalog.Preview(Collections.singletonList("ORIGINAL-001"),
|
"{\"root\":\"task\",\"field\":\"pihao_yuanchang\",\"metadataRevision\":1}");
|
});
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(input("sample.original_batch"));
|
|
LimsElnSourceCatalog.Version published = catalog.publish(draft.getId(), 0, "work-item-a");
|
|
assertEquals("PUBLISHED", published.getStatus());
|
assertEquals(published, catalog.catalog().get(0));
|
assertEquals("work-item-a", published.getValidationSampleId());
|
assertEquals("field-manager", published.getPublishedBy());
|
assertEquals("{\"root\":\"task\",\"field\":\"pihao_yuanchang\",\"metadataRevision\":1}",
|
published.getFrozenDefinitionJson());
|
}
|
|
@Test
|
public void doesNotReuseAnExistingPropertyIdentityAsANewSource() {
|
LimsElnSourceCatalog catalog = catalog(newStore());
|
catalog.createDraft(input("sample.original_batch"));
|
|
try {
|
catalog.createDraft(input("sample.original_batch"));
|
fail("A stable property code must not be reused");
|
} catch (DataException expected) {
|
assertEquals("Source property already exists", expected.getMessage());
|
}
|
}
|
|
@Test
|
public void newPublicationKeepsTheOldDefinitionAndOnlyOffersTheLatestVersion() {
|
LimsElnSourceCatalog catalog = publishingCatalog(newStore());
|
LimsElnSourceCatalog.Version first = catalog.publish(
|
catalog.createDraft(input("sample.original_batch")).getId(), 0, "work-item-a");
|
LimsElnSourceCatalog.Draft changed = input("sample.original_batch");
|
changed.getDefinition().setFieldId("supplierBatch");
|
|
LimsElnSourceCatalog.Version next = catalog.newVersion(first.getId(), changed);
|
assertEquals(first, catalog.catalog().get(0));
|
LimsElnSourceCatalog.Version second = catalog.publish(next.getId(), 0, "work-item-a");
|
|
assertEquals(2, second.getRevision());
|
assertEquals(Collections.singletonList(second), catalog.catalog());
|
assertEquals(first, catalog.published("sample.original_batch", 1));
|
assertEquals("originalBatch", catalog.definition(first.getId()).getFieldId());
|
assertEquals("supplierBatch", catalog.definition(second.getId()).getFieldId());
|
}
|
|
@Test
|
public void disablingRemovesNewChoicesButKeepsPublishedVersionsReadable() {
|
LimsElnSourceCatalog catalog = publishingCatalog(newStore());
|
LimsElnSourceCatalog.Version published = catalog.publish(
|
catalog.createDraft(input("sample.original_batch")).getId(), 0, "work-item-a");
|
|
catalog.setEnabled("sample.original_batch", false);
|
|
assertTrue(catalog.catalog().isEmpty());
|
assertEquals(published, catalog.published("sample.original_batch", 1));
|
catalog.setEnabled("sample.original_batch", true);
|
assertEquals(Collections.singletonList(published), catalog.catalog());
|
}
|
|
@Test
|
public void updatesDraftsWithOptimisticLockingAndNeverUpdatesPublishedDefinitions() {
|
LimsElnSourceCatalog catalog = publishingCatalog(newStore());
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(input("sample.original_batch"));
|
LimsElnSourceCatalog.Draft changed = input("sample.original_batch");
|
changed.getDefinition().setFieldId("supplierBatch");
|
|
LimsElnSourceCatalog.Version updated = catalog.updateDraft(draft.getId(), 0, changed);
|
|
assertEquals(1, updated.getEditVersion());
|
assertEquals("supplierBatch", catalog.definition(draft.getId()).getFieldId());
|
try {
|
catalog.updateDraft(draft.getId(), 0, input("sample.original_batch"));
|
fail("Stale editors must not overwrite a draft");
|
} catch (DataException expected) {
|
assertEquals("Source version has changed", expected.getMessage());
|
}
|
LimsElnSourceCatalog.Version published = catalog.publish(draft.getId(), updated.getEditVersion(), "work-item-a");
|
try {
|
catalog.updateDraft(draft.getId(), published.getEditVersion(), changed);
|
fail("A published source must not be edited in place");
|
} catch (DataException expected) {
|
assertEquals("Published source is immutable", expected.getMessage());
|
}
|
assertEquals(published, catalog.published("sample.original_batch", 1));
|
}
|
|
@Test
|
public void recordCallersCanResolveFixedVersionsWithoutReceivingMaintenancePermission() {
|
LimsElnSourceCatalog.Store store = newStore();
|
LimsElnSourceCatalog manager = publishingCatalog(store);
|
LimsElnSourceCatalog.Version published = manager.publish(
|
manager.createDraft(input("sample.original_batch")).getId(), 0, "work-item-a");
|
LimsElnSourceCatalog recordCaller = new LimsElnSourceCatalog(store,
|
() -> new LimsElnSourceCatalog.Actor("0", "inspector", false));
|
|
assertEquals(published, recordCaller.published("sample.original_batch", 1));
|
|
try {
|
recordCaller.createDraft(input("sample.other"));
|
fail("A record caller must not gain field management permission");
|
} catch (DataException expected) {
|
assertEquals("Field management permission required", expected.getMessage());
|
}
|
}
|
|
@Test
|
public void validatesNativeScalarTypesWithoutReinterpretingTextOrRoundingNumbers() {
|
Map<String, Object> samples = new LinkedHashMap<>();
|
samples.put("DECIMAL", new BigDecimal("1.234567890123456789"));
|
samples.put("DATE", LocalDate.of(2026, 9, 5));
|
samples.put("DATETIME", OffsetDateTime.parse("2026-09-05T12:30:00+08:00"));
|
samples.put("BOOLEAN", Boolean.TRUE);
|
for (Map.Entry<String, Object> sample : samples.entrySet()) {
|
LimsElnSourceCatalog catalog = new LimsElnSourceCatalog(newStore(),
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true),
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Collections.singletonList(sample.getValue()), "{\"metadataRevision\":1}"));
|
LimsElnSourceCatalog.Draft input = input("sample.typed_value_" + sample.getKey());
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(new LimsElnSourceCatalog.Draft(
|
input.getPropertyCode(), input.getDisplayName(), sample.getKey(), input.getDefinition()));
|
|
assertEquals(sample.getKey(), catalog.publish(draft.getId(), 0, "work-item-a").getDataType());
|
}
|
}
|
|
@Test
|
public void blankSampleValuesDoNotCountAsSuccessfulPublicationValidation() {
|
LimsElnSourceCatalog catalog = new LimsElnSourceCatalog(newStore(),
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true),
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Collections.singletonList(" "), "{\"metadataRevision\":1}"));
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(input("sample.original_batch"));
|
|
try {
|
catalog.publish(draft.getId(), 0, "work-item-a");
|
fail("Blank data is not a successful sample");
|
} catch (DataException expected) {
|
assertEquals("Source preview must resolve one value", expected.getMessage());
|
}
|
assertEquals(draft, catalog.detail(draft.getId()));
|
assertTrue(catalog.catalog().isEmpty());
|
}
|
|
@Test
|
public void anOldEditorCannotPublishSomeoneElsesUpdatedDraft() {
|
LimsElnSourceCatalog catalog = publishingCatalog(newStore());
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(input("sample.original_batch"));
|
LimsElnSourceCatalog.Draft changed = input("sample.original_batch");
|
changed.getDefinition().setFieldId("supplierBatch");
|
LimsElnSourceCatalog.Version updated = catalog.updateDraft(draft.getId(), 0, changed);
|
|
try {
|
catalog.publish(draft.getId(), 0, "work-item-a");
|
fail("Publication must check the editor version before reading data");
|
} catch (DataException expected) {
|
assertEquals("Source version has changed", expected.getMessage());
|
}
|
assertEquals(updated, catalog.detail(draft.getId()));
|
}
|
|
@Test
|
public void failedOrAmbiguousPreviewsNeverPublishTheDraft() {
|
List<LimsElnSourceCatalog.SourceReader> readers = Arrays.asList(
|
(definition, actor, sampleId) -> { throw new DataException("Sample is not authorized"); },
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Arrays.asList("same-value", "same-value"), "{\"metadataRevision\":1}"),
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Collections.singletonList(123), "{\"metadataRevision\":1}"),
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Collections.singletonList("value"), " "),
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Collections.singletonList("value"), "{}"));
|
for (int i = 0; i < readers.size(); i++) {
|
LimsElnSourceCatalog catalog = new LimsElnSourceCatalog(newStore(),
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true), readers.get(i));
|
LimsElnSourceCatalog.Version draft = catalog.createDraft(input("sample.invalid_" + i));
|
try {
|
catalog.publish(draft.getId(), 0, "work-item-a");
|
fail("Unsuccessful validation must never publish a source");
|
} catch (DataException expected) {
|
assertEquals(draft, catalog.detail(draft.getId()));
|
}
|
assertTrue(catalog.catalog().isEmpty());
|
}
|
}
|
|
@Test
|
public void draftMetadataMustHaveABusinessNameAndASupportedScalarType() {
|
LimsElnSourceCatalog catalog = catalog(newStore());
|
LimsElnSourceCatalog.Draft source = input("sample.original_batch");
|
for (LimsElnSourceCatalog.Draft invalid : Arrays.asList(
|
new LimsElnSourceCatalog.Draft(source.getPropertyCode(), " ", "TEXT", source.getDefinition()),
|
new LimsElnSourceCatalog.Draft(source.getPropertyCode(), "Name", "SCRIPT", source.getDefinition()))) {
|
try {
|
catalog.createDraft(invalid);
|
fail("Invalid metadata must be rejected before persistence");
|
} catch (DataException expected) {
|
assertTrue(catalog.catalog().isEmpty());
|
}
|
}
|
assertEquals("DRAFT", catalog.createDraft(source).getStatus());
|
}
|
|
@Test
|
public void editingDuringPreviewInvalidatesThePendingPublication() {
|
AtomicReference<LimsElnSourceCatalog> reference = new AtomicReference<>();
|
AtomicReference<String> draftId = new AtomicReference<>();
|
LimsElnSourceCatalog catalog = new LimsElnSourceCatalog(newStore(),
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true),
|
(definition, actor, sampleId) -> {
|
LimsElnSourceCatalog.Draft changed = input("sample.original_batch");
|
changed.getDefinition().setFieldId("supplierBatch");
|
reference.get().updateDraft(draftId.get(), 0, changed);
|
return new LimsElnSourceCatalog.Preview(
|
Collections.singletonList("ORIGINAL-001"), "{\"metadataRevision\":1}");
|
});
|
reference.set(catalog);
|
draftId.set(catalog.createDraft(input("sample.original_batch")).getId());
|
|
try {
|
catalog.publish(draftId.get(), 0, "work-item-a");
|
fail("Validation of an old definition must not publish an updated draft");
|
} catch (DataException expected) {
|
assertEquals("Source version has changed", expected.getMessage());
|
}
|
assertEquals("supplierBatch", catalog.definition(draftId.get()).getFieldId());
|
assertTrue(catalog.catalog().isEmpty());
|
}
|
|
private static LimsElnSourceCatalog publishingCatalog(LimsElnSourceCatalog.Store store) {
|
return new LimsElnSourceCatalog(store,
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true),
|
(definition, actor, sampleId) -> new LimsElnSourceCatalog.Preview(
|
Collections.singletonList("ORIGINAL-001"), "{\"metadataRevision\":1}"));
|
}
|
|
private static LimsElnSourceCatalog catalog(LimsElnSourceCatalog.Store store) {
|
return new LimsElnSourceCatalog(store,
|
() -> new LimsElnSourceCatalog.Actor("0", "field-manager", true));
|
}
|
|
private static LimsElnSourceCatalog.Draft input(String code) {
|
LimsElnSourceCatalog.Definition definition = new LimsElnSourceCatalog.Definition();
|
definition.setObjectId("testRequest");
|
definition.setFieldId("originalBatch");
|
return new LimsElnSourceCatalog.Draft(code, "Original batch", "TEXT", definition);
|
}
|
|
protected LimsElnSourceCatalog.Store newStore() {
|
return new MemoryStore();
|
}
|
|
private static final class MemoryStore implements LimsElnSourceCatalog.Store {
|
private final Map<String, LimsElnSourceCatalog.Version> versions = new LinkedHashMap<>();
|
private final Map<String, Boolean> enabled = new LinkedHashMap<>();
|
|
@Override
|
public boolean enabled(String tenantId, String code) {
|
return enabled.getOrDefault(tenantId + ":" + code, true);
|
}
|
|
@Override
|
public Map<String, Boolean> enabledStates(String tenantId) {
|
Map<String, Boolean> result = new LinkedHashMap<>();
|
versions.values().stream().filter(version -> tenantId.equals(version.getTenantId()))
|
.forEach(version -> result.put(version.getPropertyCode(), enabled(tenantId, version.getPropertyCode())));
|
return result;
|
}
|
|
@Override
|
public void setEnabled(String tenantId, String code, boolean value) {
|
enabled.put(tenantId + ":" + code, value);
|
}
|
|
@Override
|
public void insert(LimsElnSourceCatalog.Version version) {
|
versions.put(version.getId(), version);
|
}
|
|
@Override
|
public boolean replaceDraft(LimsElnSourceCatalog.Version expected,
|
LimsElnSourceCatalog.Version replacement) {
|
return versions.replace(expected.getId(), expected, replacement);
|
}
|
|
@Override
|
public LimsElnSourceCatalog.Version find(String tenantId, String id) {
|
LimsElnSourceCatalog.Version version = versions.get(id);
|
return version != null && tenantId.equals(version.getTenantId()) ? version : null;
|
}
|
|
@Override
|
public List<LimsElnSourceCatalog.Version> list(String tenantId) {
|
return versions.values().stream().filter(v -> tenantId.equals(v.getTenantId()))
|
.collect(Collectors.toList());
|
}
|
}
|
}
|
