初始化

刘光辉

昨天 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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package jnpf.dmsMapper;
 
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ResultMapping;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.Test;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
 
class DmsWenjianBianhaoMapperXmlTest {
 
    private static final List<String> MAPPERS = Arrays.asList(
            "DmsWenjianBianhaoGuizeMapper",
            "DmsWenjianBianhaoGuizeZixiangMapper",
            "DmsWenjianBianhaoLiushuiJishuMapper",
            "DmsWenjianBianhaoMapper",
            "DmsWenjianBianhaoShenqingMapper",
            "DmsWenjianMingchengBiangengShenqingMapper");
 
    @Test
    void allFileNumberMappersUseXmlWithoutSelectStar() throws IOException {
        for (String mapper : MAPPERS) {
            String resource = resource(mapper);
            String xml;
            try (Reader reader = Resources.getResourceAsReader(resource)) {
                xml = read(reader);
            }
            assertFalse(xml.toUpperCase().contains("SELECT *"), resource);
            parse(resource);
        }
    }
 
    @Test
    void applicationFlowStateHasExplicitResultMapping() throws IOException {
        Configuration configuration = parse(resource("DmsWenjianBianhaoShenqingMapper"));
        assertMapping(configuration,
                DmsWenjianBianhaoShenqingMapper.class.getName() + ".selectByFlowForUpdate",
                "f_flow_state", "flowState");
    }
 
    @Test
    void nameChangeFlowStateHasExplicitResultMapping() throws IOException {
        Configuration configuration = parse(
                resource("DmsWenjianMingchengBiangengShenqingMapper"));
        assertMapping(configuration,
                DmsWenjianMingchengBiangengShenqingMapper.class.getName()
                        + ".selectByFlowForUpdate",
                "f_flow_state", "flowState");
    }
 
    @Test
    void usingNumberCandidatesExcludeActiveNameChangesButEchoRemainsAvailable()
            throws IOException {
        Configuration configuration = parse(resource("DmsWenjianBianhaoMapper"));
        String statementId = DmsWenjianBianhaoMapper.class.getName() + ".selectUsingPage";
        Map<String, Object> parameters = new HashMap<>();
        parameters.put("bianhaoId", "");
        parameters.put("keyword", "");
        String candidateSql = normalize(configuration.getMappedStatement(statementId)
                .getBoundSql(parameters).getSql());
        assertTrue(candidateSql.contains("NOT EXISTS"));
        assertTrue(candidateSql.contains("c.f_flow_state IN (1, 5, 6, 8, 10)"));
 
        parameters.put("bianhaoId", "number-1");
        String echoSql = normalize(configuration.getMappedStatement(statementId)
                .getBoundSql(parameters).getSql());
        assertFalse(echoSql.contains("NOT EXISTS"));
        assertTrue(echoSql.contains("b.f_id = ?"));
    }
 
    private Configuration parse(String resource) throws IOException {
        Configuration configuration = new Configuration();
        try (InputStream input = Resources.getResourceAsStream(resource)) {
            XMLMapperBuilder builder = new XMLMapperBuilder(
                    input, configuration, resource, configuration.getSqlFragments());
            builder.parse();
        }
        return configuration;
    }
 
    private void assertMapping(Configuration configuration, String statementId,
                               String column, String property) {
        MappedStatement statement = configuration.getMappedStatement(statementId);
        boolean mapped = statement.getResultMaps().stream()
                .flatMap(resultMap -> resultMap.getResultMappings().stream())
                .anyMatch(mapping -> matches(mapping, column, property));
        assertTrue(mapped, column + " must map explicitly to " + property);
    }
 
    private boolean matches(ResultMapping mapping, String column, String property) {
        return column.equals(mapping.getColumn()) && property.equals(mapping.getProperty());
    }
 
    private String read(Reader reader) throws IOException {
        StringBuilder result = new StringBuilder();
        char[] buffer = new char[2048];
        int length;
        while ((length = reader.read(buffer)) >= 0) {
            result.append(buffer, 0, length);
        }
        return result.toString();
    }
 
    private String normalize(String sql) {
        return sql.replaceAll("\\s+", " ").trim();
    }
 
    private String resource(String mapper) {
        return "mapper/" + mapper + ".xml";
    }
}