Initial commit: bositao cloud (jnpf-java-cloud-v6x)

刘光辉

6 小时以前 06f314545ac3514d7ce28939920866ae8188d31c

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
package jnpf.elnMapper;
 
import jnpf.elnEntity.formula.ElnFormulaDefEntity;
import jnpf.elnEntity.formula.ElnFormulaParameterSlotEntity;
import jnpf.elnEntity.formula.ElnFormulaVersionEntity;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Update;
import org.junit.Test;
 
import java.lang.reflect.Method;
 
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
 
public class ElnFormulaMapperContractTest {
 
    @Test
    public void definitionUpdateUsesTenantIdAndOptimisticVersion() throws Exception {
        String sql = updateSql(ElnFormulaDefMapper.class,
                "updateMutableByTenantAndVersion", ElnFormulaDefEntity.class);
 
        assertTenantIdVersionGuard(sql);
        assertTrue(sql.contains("gongshi_mingcheng ="));
        assertTrue(sql.contains("f_version = f_version + 1"));
        assertFalse(sql.contains("gongshi_bianma ="));
        assertFalse(setClause(sql).contains("f_tenant_id ="));
    }
 
    @Test
    public void versionUpdateUsesTenantIdAndOptimisticVersion() throws Exception {
        String sql = updateSql(ElnFormulaVersionMapper.class,
                "updateMutableByTenantAndVersion", ElnFormulaVersionEntity.class);
 
        assertTenantIdVersionGuard(sql);
        assertTrue(sql.contains("biaodashi ="));
        assertTrue(sql.contains("biz_status ="));
        assertFalse(sql.contains("gongshi_dingyi_id ="));
        assertFalse(sql.contains("banben_hao ="));
    }
 
    @Test
    public void slotUpdateAndDeleteUseTenantIdAndOptimisticVersion() throws Exception {
        String updateSql = updateSql(ElnFormulaParameterSlotMapper.class,
                "updateMutableByTenantAndVersion", ElnFormulaParameterSlotEntity.class);
        assertTenantIdVersionGuard(updateSql);
        assertTrue(updateSql.contains("canshu_mingcheng ="));
        assertFalse(updateSql.contains("canshu_bianma ="));
        assertFalse(updateSql.contains("gongshi_banben_id ="));
 
        Method deleteMethod = ElnFormulaParameterSlotMapper.class.getDeclaredMethod(
                "deleteByTenantAndVersion", ElnFormulaParameterSlotEntity.class, Integer.class);
        String deleteSql = normalize(String.join(" ",
                deleteMethod.getAnnotation(Delete.class).value()));
        assertTenantIdVersionGuard(deleteSql);
    }
 
    @Test
    public void slotInsertIgnoresOnlyTenantVersionAndParameterCodeConflict() {
        Method insertMethod = null;
        for (Method method : ElnFormulaParameterSlotMapper.class.getDeclaredMethods()) {
            if (method.getAnnotation(Insert.class) != null) {
                insertMethod = method;
                break;
            }
        }
        assertTrue(insertMethod != null);
 
        String sql = normalize(String.join(" ", insertMethod.getAnnotation(Insert.class).value()));
        assertTrue(sql.contains("insert into eln_formula_parameter_slot (gongshi_banben_id, "
                + "canshu_bianma, canshu_mingcheng, shuju_leixing, danwei, shifou_bitian, "
                + "paixu, f_id, f_tenant_id, f_version, f_creator_user_id, f_creator_time, "
                + "f_last_modify_user_id, f_last_modify_time, f_delete_user_id, f_delete_time, "
                + "f_delete_mark) values ("));
        assertTrue(sql.contains("on conflict (f_tenant_id, gongshi_banben_id, canshu_bianma) "
                + "do nothing"));
    }
 
    private static String updateSql(Class<?> mapper, String name, Class<?> entity)
            throws Exception {
        Method method = mapper.getDeclaredMethod(name, entity, Integer.class);
        return normalize(String.join(" ", method.getAnnotation(Update.class).value()));
    }
 
    private static void assertTenantIdVersionGuard(String sql) {
        assertTrue(sql.contains("where f_tenant_id = #{entity.ftenantid}"));
        assertTrue(sql.contains("and f_id = #{entity.id}"));
        assertTrue(sql.contains("and f_version = #{expectedversion}"));
    }
 
    private static String normalize(String sql) {
        return sql.toLowerCase().replaceAll("\\s+", " ").trim();
    }
 
    private static String setClause(String sql) {
        return sql.substring(0, sql.indexOf(" where "));
    }
}