package cn.iocoder.yudao.module.qcreport.engine;
|
|
import cn.iocoder.yudao.module.qcreport.dal.dataobject.version.ReportTemplateSchema;
|
import cn.iocoder.yudao.module.qcreport.engine.context.InspectionItem;
|
import cn.iocoder.yudao.module.qcreport.engine.context.ReportContext;
|
import cn.iocoder.yudao.module.qcreport.engine.render.RenderOutcome;
|
import cn.iocoder.yudao.module.qcreport.engine.report.EvaluationOutcome;
|
import cn.iocoder.yudao.module.qcreport.engine.report.ReportEvaluator;
|
import cn.iocoder.yudao.module.qcreport.engine.rule.QualityRuleDefinition;
|
import cn.iocoder.yudao.module.qcreport.engine.rule.RuleEngine;
|
import com.fasterxml.jackson.databind.JsonNode;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import org.junit.jupiter.api.DisplayName;
|
import org.junit.jupiter.api.Test;
|
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
|
/**
|
* 与前端引擎的一致性测试。
|
* <p>
|
* 渲染引擎与规则引擎在前端（{@code src/components/quality/engine}）各有一套实现，
|
* 设计器预览用前端那套、服务端生成报告用这套，两边结果不一致就等于「预览与出件不符」，
|
* 那是比少个功能更难查的问题。所以这里用同一份 fixture 跑两边，逐字比对产物。
|
* <p>
|
* fixture 与期望产物都在 {@code src/test/resources/qcreport/}：
|
* schema.json / context.json 是输入，expected-html.html 与 expected-rules.json 是前端引擎的产物。
|
* 期望产物由前端引擎跑 {@code mom-pro2-before/.qc-conformance/render-ts.ts} 生成后冻结；
|
* 改动任何一侧的引擎后要重新生成，再让这个测试把差异顶出来。
|
*/
|
class FrontendConformanceTest {
|
|
private static final ObjectMapper MAPPER = new ObjectMapper();
|
|
private static final String FIXTURE = "qcreport/";
|
|
@Test
|
@DisplayName("渲染产物与前端引擎逐字一致")
|
void renderMatchesFrontendEngine() throws IOException {
|
ReportTemplateSchema schema = readSchema();
|
ReportContext context = readContext();
|
|
RenderOutcome outcome = QualityReportEngine.render(schema, context);
|
|
assertEquals(readFixture("expected-html.html"), outcome.html(),
|
"服务端渲染的 HTML 与前端引擎不一致，预览和出件会对不上");
|
assertEquals(readErrors(), outcome.errors(), "数据缺口清单与前端引擎不一致");
|
}
|
|
@Test
|
@DisplayName("判定结果与前端引擎一致")
|
void evaluationMatchesFrontendEngine() throws IOException {
|
ReportTemplateSchema schema = readSchema();
|
ReportContext context = readContext();
|
|
EvaluationOutcome evaluated = ReportEvaluator.evaluate(context, QualityReportEngine.rulesOf(schema));
|
|
assertEquals("FAIL", evaluated.context().getReport().getResult());
|
assertEquals("不合格", evaluated.context().getReport().getResultText());
|
assertEquals(3, evaluated.context().getReport().getTotal());
|
assertEquals(1, evaluated.context().getReport().getPassCount());
|
assertEquals(2, evaluated.context().getReport().getFailCount());
|
assertEquals("33.33%", evaluated.context().getReport().getPassRate());
|
|
List<InspectionItem> items = evaluated.context().getInspectionItems();
|
assertEquals(List.of("FAIL", "PASS", "FAIL"), List.of(
|
items.get(0).getResult(), items.get(1).getResult(), items.get(2).getResult()),
|
"外观无上下限但有规则、长度在规格内、硬度超上限");
|
}
|
|
@Test
|
@DisplayName("规则求值与前端引擎一致（含报错文案）")
|
void rulesMatchFrontendEngine() throws IOException {
|
ReportTemplateSchema schema = readSchema();
|
List<QualityRuleDefinition> rules = QualityReportEngine.rulesOf(schema);
|
ReportContext evaluated = ReportEvaluator.evaluate(readContext(), rules).context();
|
|
Map<String, Map<String, Object>> scopes = buildScopes(evaluated);
|
JsonNode expected = MAPPER.readTree(readFixture("expected-rules.json"));
|
|
for (JsonNode item : expected.get("results")) {
|
String expression = item.get("expression").asText();
|
String scope = item.get("scope").asText();
|
Map<String, Object> context = scopes.get(scope);
|
String label = scope + " / " + expression;
|
|
if (item.has("error")) {
|
RuntimeException error = assertThrows(RuntimeException.class,
|
() -> RuleEngine.evaluate(expression, context), label);
|
assertEquals(item.get("error").asText(), error.getMessage(), label);
|
continue;
|
}
|
Object value = RuleEngine.evaluate(expression, context);
|
assertEquals(item.get("kind").asText(), kindOf(value), label + " 的结果类型不一致");
|
assertEquals(item.get("text").asText(), JsValues.asText(value), label + " 的结果文本不一致");
|
}
|
}
|
|
/* ------------------------------ 辅助 ------------------------------ */
|
|
private static Map<String, Map<String, Object>> buildScopes(ReportContext evaluated) {
|
List<InspectionItem> items = evaluated.getInspectionItems();
|
|
Map<String, Object> report = evaluated.toScope();
|
report.put("index", 0);
|
|
Map<String, Object> item2 = evaluated.toScope();
|
item2.put("item", ReportContext.itemMap(items.get(1)));
|
item2.put("index", 2);
|
|
Map<String, Object> item3 = evaluated.toScope();
|
item3.put("item", ReportContext.itemMap(items.get(2)));
|
item3.put("index", 3);
|
|
Map<String, Map<String, Object>> scopes = new LinkedHashMap<>();
|
scopes.put("report", report);
|
scopes.put("item2", item2);
|
scopes.put("item3", item3);
|
return scopes;
|
}
|
|
/** 与 JS 的 typeof 对齐：null/undefined 记为 nil，数组与对象都是 object */
|
private static String kindOf(Object value) {
|
if (value == null) {
|
return "nil";
|
}
|
if (value instanceof Boolean) {
|
return "boolean";
|
}
|
if (value instanceof Number) {
|
return "number";
|
}
|
if (value instanceof String) {
|
return "string";
|
}
|
return "object";
|
}
|
|
private static List<String> readErrors() throws IOException {
|
JsonNode node = MAPPER.readTree(readFixture("expected-rules.json")).get("errors");
|
List<String> errors = new ArrayList<>();
|
node.forEach(item -> errors.add(item.asText()));
|
return errors;
|
}
|
|
private static ReportTemplateSchema readSchema() throws IOException {
|
return MAPPER.readValue(readFixture("schema.json"), ReportTemplateSchema.class);
|
}
|
|
private static ReportContext readContext() throws IOException {
|
return MAPPER.readValue(readFixture("context.json"), ReportContext.class);
|
}
|
|
private static String readFixture(String name) throws IOException {
|
try (InputStream in = FrontendConformanceTest.class.getClassLoader()
|
.getResourceAsStream(FIXTURE + name)) {
|
if (in == null) {
|
throw new IOException("测试 fixture 缺失：" + FIXTURE + name);
|
}
|
return new String(in.readAllBytes(), StandardCharsets.UTF_8);
|
}
|
}
|
|
}
|
