初始化

刘光辉

昨天 bb638871a7fb692d80f1b7a758f991dc0879002c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package jnpf.bizcommon.audit.service.listener;
 
import com.alibaba.fastjson.JSON;
import jnpf.audit.diff.AuditFieldDiff;
 
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
/** Regression checks for database-before/database-after Layer 0 diffs. */
public final class AuditL0PartialSnapshotProbe {
 
    private AuditL0PartialSnapshotProbe() {
    }
 
    public static void main(String[] args) {
        Map<String, Object> before = row(
                "yangpin_mingcheng", "旧名称",
                "beizhu", "待清空",
                "biz_sign", "old-sign",
                "f_version", "0",
                "child_table", "old-child");
        Map<String, Object> after = row(
                "yangpin_mingcheng", "红细胞",
                "jieshou_shuliang", "6",
                "biz_sign", "new-sign",
                "f_version", "1",
                "child_table", "new-child");
        Set<String> masked = new LinkedHashSet<String>(Collections.singletonList("biz_sign"));
        Set<String> childFields = new LinkedHashSet<String>(Collections.singletonList("child_table"));
 
        String diff = AuditVisualLogListener.databaseBoundaryDiff(
                before, after, masked, Collections.emptyMap(), childFields);
        List<Map<String, Object>> items = parse(diff);
        check("changed field", item(items, "yangpin_mingcheng", "旧名称", "红细胞", 1));
        check("new field is addition", item(items, "jieshou_shuliang", "", "6", 0));
        check("missing after field is clear", item(items, "beizhu", "待清空", "", 1));
        check("masked field compared without leaking values",
                item(items, "biz_sign", AuditFieldDiff.MASKED, AuditFieldDiff.MASKED, 1));
        check("technical field excluded", find(items, "f_version") == null);
        check("child field excluded", find(items, "child_table") == null);
 
        String unchanged = AuditVisualLogListener.databaseBoundaryDiff(
                row("name", "same"), row("name", "same"),
                Collections.emptySet(), Collections.emptyMap(), Collections.emptySet());
        check("unchanged row", parse(unchanged).isEmpty());
    }
 
    @SuppressWarnings("unchecked")
    private static List<Map<String, Object>> parse(String json) {
        return (List<Map<String, Object>>) (List<?>) JSON.parseArray(json, Map.class);
    }
 
    private static boolean item(List<Map<String, Object>> items, String field,
                                String oldData, String newData, int type) {
        Map<String, Object> item = find(items, field);
        return item != null
                && oldData.equals(String.valueOf(item.get("oldData")))
                && newData.equals(String.valueOf(item.get("newData")))
                && type == ((Number) item.get("type")).intValue();
    }
 
    private static Map<String, Object> find(List<Map<String, Object>> items, String field) {
        for (Map<String, Object> item : items) {
            if (field.equals(item.get("field"))) {
                return item;
            }
        }
        return null;
    }
 
    private static Map<String, Object> row(Object... values) {
        Map<String, Object> row = new LinkedHashMap<String, Object>();
        for (int i = 0; i < values.length; i += 2) {
            row.put(String.valueOf(values[i]), values[i + 1]);
        }
        return row;
    }
 
    private static void check(String label, boolean condition) {
        if (!condition) {
            throw new AssertionError(label);
        }
    }
}