package jnpf.elnService.impl;
|
|
import jnpf.elnEntity.formula.ElnFormulaParameterSlotEntity;
|
import jnpf.elnEntity.formula.ElnFormulaVersionEntity;
|
import jnpf.elnEntity.formula.ElnTemplateFormulaBindingEntity;
|
import jnpf.elnEntity.runtime.ElnFormulaCalculationLogEntity;
|
import jnpf.elnEntity.runtime.ElnRecordEntity;
|
import jnpf.elnEntity.runtime.ElnRecordFieldValueEntity;
|
import jnpf.elnEntity.runtime.ElnRecordRevisionEntity;
|
import jnpf.elnEntity.template.ElnTemplateBindingEntity;
|
import jnpf.elnMapper.ElnFormulaCalculationLogMapper;
|
import jnpf.elnMapper.ElnFormulaParameterSlotMapper;
|
import jnpf.elnMapper.ElnFormulaVersionMapper;
|
import jnpf.elnMapper.ElnTemplateBindingMapper;
|
import jnpf.elnMapper.ElnTemplateFormulaBindingMapper;
|
import jnpf.elnService.formula.FormulaDependencyGraph;
|
import jnpf.elnService.formula.impl.FormulaPreviewServiceImpl;
|
import jnpf.elnService.formula.impl.FormulaValidationServiceImpl;
|
import org.junit.Test;
|
|
import java.lang.reflect.Proxy;
|
import java.math.BigDecimal;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.concurrent.atomic.AtomicInteger;
|
|
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertNull;
|
import static org.junit.Assert.assertTrue;
|
|
public class ElnRecordFormulaCalculationServiceImplTest {
|
|
@Test
|
public void recalculatesOnlyAffectedFormulaClosureInTopologicalOrder() {
|
Fixture fixture = new Fixture(false);
|
|
List<ElnRecordFieldValueEntity> calculated = fixture.service.recalculateAffected(
|
"tenant-a", fixture.record, fixture.revision, fixture.values,
|
new LinkedHashSet<>(Collections.singletonList("input-a")),
|
"save-1", "user-1");
|
|
assertEquals(Arrays.asList("result-a", "result-b"), bindingIds(calculated));
|
assertEquals(new BigDecimal("3"), fixture.value("result-a").getZhiShuzhi());
|
assertEquals(new BigDecimal("4"), fixture.value("result-b").getZhiShuzhi());
|
assertEquals(new BigDecimal("300"), fixture.value("result-c").getZhiShuzhi());
|
assertEquals(2, fixture.logs.size());
|
assertEquals("SUCCESS", fixture.logs.get(0).getJisuanZhuangtai());
|
assertEquals("SUCCESS", fixture.logs.get(1).getJisuanZhuangtai());
|
assertEquals(new BigDecimal("2"), fixture.logs.get(0).getShuruKuaizhao().get("x"));
|
assertEquals(new BigDecimal("3"), fixture.logs.get(1).getShuruKuaizhao().get("x"));
|
}
|
|
@Test
|
public void clearsFailedFormulaAndEveryDownstreamOldResultWithLogs() {
|
Fixture fixture = new Fixture(true);
|
|
List<ElnRecordFieldValueEntity> calculated = fixture.service.recalculateAffected(
|
"tenant-a", fixture.record, fixture.revision, fixture.values,
|
new LinkedHashSet<>(Collections.singletonList("input-a")),
|
"save-2", "user-1");
|
|
assertEquals(Arrays.asList("result-a", "result-b"), bindingIds(calculated));
|
assertNull(fixture.value("result-a").getZhiWenben());
|
assertNull(fixture.value("result-a").getZhiShuzhi());
|
assertNull(fixture.value("result-b").getZhiWenben());
|
assertNull(fixture.value("result-b").getZhiShuzhi());
|
assertEquals("MISSING_INPUT", fixture.value("result-a").getJisuanZhuangtai());
|
assertEquals("MISSING_INPUT", fixture.value("result-b").getJisuanZhuangtai());
|
assertEquals(new BigDecimal("300"), fixture.value("result-c").getZhiShuzhi());
|
assertEquals(2, fixture.logs.size());
|
assertEquals("MISSING_INPUT", fixture.logs.get(0).getJisuanZhuangtai());
|
assertEquals("MISSING_INPUT", fixture.logs.get(1).getJisuanZhuangtai());
|
}
|
|
@Test
|
public void recordsDownstreamAsMissingWhenUpstreamFormulaErrors() {
|
Fixture fixture = new Fixture(false);
|
fixture.value("input-a").setZhiShuzhi(null);
|
fixture.value("input-a").setZhiWenben("invalid-number");
|
|
fixture.service.recalculateAffected(
|
"tenant-a", fixture.record, fixture.revision, fixture.values,
|
new LinkedHashSet<>(Collections.singletonList("input-a")),
|
"save-3", "user-1");
|
|
assertEquals("ERROR", fixture.value("result-a").getJisuanZhuangtai());
|
assertEquals("MISSING_INPUT", fixture.value("result-b").getJisuanZhuangtai());
|
assertNull(fixture.value("result-b").getZhiShuzhi());
|
assertEquals("MISSING_INPUT", fixture.logs.get(1).getJisuanZhuangtai());
|
assertTrue(fixture.logs.get(1).getShibaiYuanyin()
|
.contains("code-result-a"));
|
}
|
|
@Test
|
public void recalculatesEveryFormulaInTopologicalOrder() {
|
Fixture fixture = new Fixture(false);
|
|
List<ElnRecordFieldValueEntity> calculated = fixture.service.recalculateAll(
|
"tenant-a", fixture.record, fixture.revision, fixture.values,
|
"all-1", "user-1");
|
|
assertEquals(Arrays.asList("result-a", "result-b", "result-c"),
|
bindingIds(calculated));
|
assertEquals(new BigDecimal("3"), fixture.value("result-a").getZhiShuzhi());
|
assertEquals(new BigDecimal("4"), fixture.value("result-b").getZhiShuzhi());
|
assertEquals(new BigDecimal("10"), fixture.value("result-c").getZhiShuzhi());
|
assertEquals(3, fixture.logs.size());
|
}
|
|
private static List<String> bindingIds(List<ElnRecordFieldValueEntity> values) {
|
List<String> result = new ArrayList<>();
|
for (ElnRecordFieldValueEntity value : values) result.add(value.getMubanBangdingId());
|
return result;
|
}
|
|
private static final class Fixture {
|
private final ElnRecordEntity record = new ElnRecordEntity();
|
private final ElnRecordRevisionEntity revision = new ElnRecordRevisionEntity();
|
private final List<ElnRecordFieldValueEntity> values = new ArrayList<>();
|
private final List<ElnFormulaCalculationLogEntity> logs = new ArrayList<>();
|
private final ElnRecordFormulaCalculationServiceImpl service;
|
|
private Fixture(boolean missingInput) {
|
record.setId("record-1");
|
record.setMubanId("template-1");
|
revision.setId("revision-1");
|
revision.setDianziJiluId(record.getId());
|
|
List<ElnTemplateFormulaBindingEntity> formulas = Arrays.asList(
|
formula("formula-a", "definition-a", "version-a", "input-a", "result-a"),
|
formula("formula-b", "definition-b", "version-b", "result-a", "result-b"),
|
formula("formula-c", "definition-c", "version-c", "input-c", "result-c"));
|
List<ElnTemplateBindingEntity> bindings = Arrays.asList(
|
binding("input-a"), binding("result-a"), binding("result-b"),
|
binding("input-c"), binding("result-c"));
|
values.add(value("input-a", missingInput ? null : new BigDecimal("2")));
|
values.add(value("result-a", new BigDecimal("100")));
|
values.add(value("result-b", new BigDecimal("200")));
|
values.add(value("input-c", new BigDecimal("9")));
|
values.add(value("result-c", new BigDecimal("300")));
|
AtomicInteger versionIndex = new AtomicInteger();
|
AtomicInteger slotIndex = new AtomicInteger();
|
List<ElnFormulaVersionEntity> versions = Arrays.asList(
|
version("version-a", "definition-a"),
|
version("version-b", "definition-b"),
|
version("version-c", "definition-c"));
|
List<List<ElnFormulaParameterSlotEntity>> slots = Arrays.asList(
|
Collections.singletonList(slot("version-a")),
|
Collections.singletonList(slot("version-b")),
|
Collections.singletonList(slot("version-c")));
|
|
ElnTemplateFormulaBindingMapper formulaMapper = proxy(
|
ElnTemplateFormulaBindingMapper.class,
|
(method, args) -> "selectList".equals(method) ? formulas : null);
|
ElnFormulaVersionMapper versionMapper = proxy(ElnFormulaVersionMapper.class,
|
(method, args) -> "selectOne".equals(method)
|
? versions.get(versionIndex.getAndIncrement()) : null);
|
ElnFormulaParameterSlotMapper slotMapper = proxy(
|
ElnFormulaParameterSlotMapper.class,
|
(method, args) -> "selectList".equals(method)
|
? slots.get(slotIndex.getAndIncrement()) : null);
|
ElnTemplateBindingMapper bindingMapper = proxy(ElnTemplateBindingMapper.class,
|
(method, args) -> "selectList".equals(method) ? bindings : null);
|
ElnFormulaCalculationLogMapper logMapper = proxy(
|
ElnFormulaCalculationLogMapper.class, (method, args) -> {
|
if ("insert".equals(method)) {
|
logs.add((ElnFormulaCalculationLogEntity) args[0]);
|
return 1;
|
}
|
return null;
|
});
|
service = new ElnRecordFormulaCalculationServiceImpl(
|
formulaMapper, versionMapper, slotMapper, bindingMapper, logMapper,
|
new FormulaPreviewServiceImpl(new FormulaValidationServiceImpl()),
|
new FormulaDependencyGraph());
|
}
|
|
private ElnRecordFieldValueEntity value(String bindingId) {
|
for (ElnRecordFieldValueEntity value : values) {
|
if (bindingId.equals(value.getMubanBangdingId())) return value;
|
}
|
throw new AssertionError(bindingId);
|
}
|
|
private ElnRecordFieldValueEntity value(String bindingId, BigDecimal decimal) {
|
ElnRecordFieldValueEntity value = new ElnRecordFieldValueEntity();
|
value.setId("value-" + bindingId);
|
value.setDianziJiluId(record.getId());
|
value.setXiudingId(revision.getId());
|
value.setMubanId(record.getMubanId());
|
value.setMubanBangdingId(bindingId);
|
value.setZiduanDingyiId("field-" + bindingId);
|
value.setZiduanBianma("code-" + bindingId);
|
value.setZiduanBanbenId("field-version-" + bindingId);
|
value.setBangdingJuese("PRIMARY");
|
value.setBangdingZhuangtai("ACTIVE");
|
value.setZhiShuzhi(decimal);
|
value.setZhiWenben(decimal == null ? null : decimal.toPlainString());
|
if (bindingId.startsWith("result-")) value.setJisuanZhuangtai("SUCCESS");
|
return value;
|
}
|
}
|
|
private static ElnTemplateFormulaBindingEntity formula(
|
String id, String definitionId, String versionId,
|
String inputBindingId, String resultBindingId) {
|
ElnTemplateFormulaBindingEntity formula = new ElnTemplateFormulaBindingEntity();
|
formula.setId(id);
|
formula.setMubanId("template-1");
|
formula.setGongshiDingyiId(definitionId);
|
formula.setGongshiBanbenId(versionId);
|
formula.setJieguoBangdingId(resultBindingId);
|
formula.setBangdingZhuangtai("ACTIVE");
|
Map<String, String> mappings = new LinkedHashMap<>();
|
mappings.put("x", inputBindingId);
|
formula.setCanshuYingshe(mappings);
|
return formula;
|
}
|
|
private static ElnTemplateBindingEntity binding(String id) {
|
ElnTemplateBindingEntity binding = new ElnTemplateBindingEntity();
|
binding.setId(id);
|
binding.setMubanId("template-1");
|
binding.setZiduanDingyiId("field-" + id);
|
binding.setZiduanBianma("code-" + id);
|
binding.setZiduanBanbenId("field-version-" + id);
|
binding.setKongjianJuese("PRIMARY");
|
binding.setBangdingZhuangtai("ACTIVE");
|
return binding;
|
}
|
|
private static ElnFormulaVersionEntity version(String id, String definitionId) {
|
ElnFormulaVersionEntity version = new ElnFormulaVersionEntity();
|
version.setId(id);
|
version.setGongshiDingyiId(definitionId);
|
version.setBiaodashi("x + 1");
|
version.setJieguoLeixing("DECIMAL");
|
version.setBizStatus("PUBLISHED");
|
return version;
|
}
|
|
private static ElnFormulaParameterSlotEntity slot(String versionId) {
|
ElnFormulaParameterSlotEntity slot = new ElnFormulaParameterSlotEntity();
|
slot.setId("slot-" + versionId);
|
slot.setGongshiBanbenId(versionId);
|
slot.setCanshuBianma("x");
|
slot.setCanshuMingcheng("输入");
|
slot.setShujuLeixing("DECIMAL");
|
slot.setShifouBitian(1);
|
slot.setPaixu(1);
|
return slot;
|
}
|
|
@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);
|
}
|
}
|
