package jnpf.elnService.impl;
|
|
import jnpf.elnEntity.runtime.ElnRecordEntity;
|
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
|
import jnpf.elnEntity.runtime.ElnRecordFormulaCalculationResult;
|
import jnpf.elnEntity.runtime.ElnRecordRepeatValueEntity;
|
import jnpf.elnEntity.runtime.ElnRecordForms;
|
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
|
import jnpf.elnEntity.runtime.ElnRecordVos;
|
import jnpf.elnMapper.ElnRecordFieldValueMapper;
|
import jnpf.elnMapper.ElnRecordMapper;
|
import jnpf.elnMapper.ElnRecordRepeatValueMapper;
|
import jnpf.elnMapper.ElnRecordRevisionMapper;
|
import jnpf.elnService.ElnRecordFormulaCalculationService;
|
import jnpf.lims.api.model.TestWorkItemSnapshotBatch;
|
import jnpf.lims.api.model.TestWorkItemSnapshot;
|
import org.junit.Test;
|
|
import java.lang.reflect.Proxy;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import static org.junit.Assert.assertEquals;
|
|
public class ElnRecordRecalculationServiceImplTest {
|
|
@Test
|
public void protectsFullRecalculationWithTaskAccessAndRecordVersion() {
|
ElnRecordEntity record = new ElnRecordEntity();
|
record.setId("record-1");
|
record.setJianyanXiangId("item-1");
|
record.setDangqianXiudingId("revision-1");
|
record.setFVersion(7);
|
ElnRecordRevisionEntity revision = new ElnRecordRevisionEntity();
|
revision.setId("revision-1");
|
revision.setDianziJiluId("record-1");
|
revision.setBizStatus("DRAFT");
|
List<ElnRecordFieldValueEntity> values = Arrays.asList(
|
calculated("result-a", "SUCCESS"),
|
calculated("result-b", "MISSING_INPUT"),
|
calculated("result-c", "ERROR"));
|
AtomicInteger casCalls = new AtomicInteger();
|
AtomicInteger updates = new AtomicInteger();
|
AtomicInteger repeatUpdates = new AtomicInteger();
|
ElnRecordMapper recordMapper = proxy(ElnRecordMapper.class, (method, args) -> {
|
if ("selectOne".equals(method)) return record;
|
if ("advanceVersion".equals(method)) {
|
assertEquals(7, args[2]);
|
casCalls.incrementAndGet();
|
return 1;
|
}
|
return null;
|
});
|
ElnRecordRevisionMapper revisionMapper = proxy(
|
ElnRecordRevisionMapper.class,
|
(method, args) -> "selectOne".equals(method) ? revision : null);
|
ElnRecordFieldValueMapper valueMapper = proxy(
|
ElnRecordFieldValueMapper.class, (method, args) -> {
|
if ("selectList".equals(method)) return new ArrayList<>(values);
|
if ("updateById".equals(method)) {
|
updates.incrementAndGet();
|
return 1;
|
}
|
return null;
|
});
|
ElnRecordFormulaCalculationService calculation =
|
new ElnRecordFormulaCalculationService() {
|
@Override
|
public List<ElnRecordFieldValueEntity> recalculateAffected(
|
String tenantId, ElnRecordEntity record,
|
ElnRecordRevisionEntity revision,
|
List<ElnRecordFieldValueEntity> values,
|
java.util.Set<String> changedBindingIds,
|
String operationCode, String operatorUserId) {
|
return Collections.emptyList();
|
}
|
|
@Override
|
public List<ElnRecordFieldValueEntity> recalculateAll(
|
String tenantId, ElnRecordEntity actualRecord,
|
ElnRecordRevisionEntity actualRevision,
|
List<ElnRecordFieldValueEntity> actualValues,
|
String operationCode, String operatorUserId) {
|
assertEquals("tenant-a", tenantId);
|
assertEquals("operation-1", operationCode);
|
assertEquals("user-1", operatorUserId);
|
return actualValues;
|
}
|
|
@Override
|
public ElnRecordFormulaCalculationResult recalculateAllWithRepeats(
|
String tenantId, ElnRecordEntity actualRecord,
|
ElnRecordRevisionEntity actualRevision,
|
List<ElnRecordFieldValueEntity> actualValues,
|
String operationCode, String operatorUserId) {
|
ElnRecordFormulaCalculationResult result =
|
new ElnRecordFormulaCalculationResult();
|
result.setFieldValues(actualValues);
|
ElnRecordRepeatValueEntity repeat = new ElnRecordRepeatValueEntity();
|
repeat.setJisuanZhuangtai("SUCCESS");
|
result.setRepeatValues(Collections.singletonList(repeat));
|
return result;
|
}
|
};
|
ElnRecordRepeatValueMapper repeatValueMapper = proxy(
|
ElnRecordRepeatValueMapper.class, (method, args) -> {
|
if ("updateById".equals(method)) {
|
repeatUpdates.incrementAndGet();
|
return 1;
|
}
|
return null;
|
});
|
ElnRecordRecalculationServiceImpl service =
|
new ElnRecordRecalculationServiceImpl(
|
recordMapper, revisionMapper, valueMapper, repeatValueMapper,
|
(itemIds, properties) -> successfulTask(), calculation,
|
() -> new ElnRecordRecalculationServiceImpl.UserContext(
|
"tenant-a", "user-1"));
|
ElnRecordForms.Recalculate command = new ElnRecordForms.Recalculate();
|
command.setExpectedRecordVersion(7);
|
command.setOperationCode("operation-1");
|
|
ElnRecordVos.Recalculated result = service.recalculateAll("record-1", command);
|
|
assertEquals(Integer.valueOf(8), result.getRecordVersion());
|
assertEquals(2, result.getSuccessCount());
|
assertEquals(1, result.getMissingInputCount());
|
assertEquals(1, result.getErrorCount());
|
assertEquals(1, casCalls.get());
|
assertEquals(3, updates.get());
|
assertEquals(1, repeatUpdates.get());
|
}
|
|
private static ElnRecordFieldValueEntity calculated(String bindingId, String status) {
|
ElnRecordFieldValueEntity value = new ElnRecordFieldValueEntity();
|
value.setMubanBangdingId(bindingId);
|
value.setJisuanZhuangtai(status);
|
return value;
|
}
|
|
private static TestWorkItemSnapshotBatch successfulTask() {
|
TestWorkItemSnapshot item = new TestWorkItemSnapshot();
|
item.setTestWorkItemId("item-1");
|
item.setOutcomeCode("SUCCESS");
|
TestWorkItemSnapshotBatch batch = new TestWorkItemSnapshotBatch();
|
batch.setItems(Collections.singletonList(item));
|
return batch;
|
}
|
|
@SuppressWarnings("unchecked")
|
private static <T> T proxy(Class<T> type, Invocation invocation) {
|
return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type},
|
(target, method, args) -> {
|
if (method.getDeclaringClass() == Object.class) {
|
if ("toString".equals(method.getName())) return type.getSimpleName();
|
if ("hashCode".equals(method.getName())) return System.identityHashCode(target);
|
if ("equals".equals(method.getName())) return target == args[0];
|
}
|
Object result = invocation.invoke(method.getName(), args);
|
if (result != null || !method.getReturnType().isPrimitive()) return result;
|
if (method.getReturnType() == boolean.class) return false;
|
return 0;
|
});
|
}
|
|
@FunctionalInterface
|
private interface Invocation {
|
Object invoke(String method, Object[] args);
|
}
|
}
|
