刘光辉
5 小时以前 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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
package jnpf.dmsService;
 
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import jnpf.dmsEntity.DmsWenjianFushenJihuaFenpeiEntity;
import jnpf.dmsEntity.DmsWenjianFushenJihuaFenpeiZixiangEntity;
import jnpf.dmsMapper.DmsWenjianFushenJihuaFenpeiMapper;
import jnpf.dmsMapper.DmsWenjianFushenJihuaFenpeiZixiangMapper;
import jnpf.dmsService.impl.DmsWenjianFushenJihuaFenpeiSyncServiceImpl;
import jnpf.exception.DataException;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.apache.ibatis.session.Configuration;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
 
import java.util.Arrays;
import java.util.Date;
import java.util.List;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
 
class DmsWenjianFushenJihuaFenpeiSyncServiceTest {
 
    @BeforeEach
    void setUp() {
        initTableInfo(DmsWenjianFushenJihuaFenpeiEntity.class);
        initTableInfo(DmsWenjianFushenJihuaFenpeiZixiangEntity.class);
    }
 
    @Test
    void syncsEveryChildWithTheAssignmentValuesFromThePlan() throws Exception {
        DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper = mock(DmsWenjianFushenJihuaFenpeiMapper.class);
        DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper = mock(
                DmsWenjianFushenJihuaFenpeiZixiangMapper.class);
        Date assignedAt = new Date();
        when(fenpeiMapper.selectOne(any())).thenReturn(fenpei("dept-1", "user-1", assignedAt));
        DmsWenjianFushenJihuaFenpeiSyncService service = service(fenpeiMapper, zixiangMapper);
 
        service.sync("plan-1");
 
        ArgumentCaptor<Wrapper<DmsWenjianFushenJihuaFenpeiZixiangEntity>> captor = ArgumentCaptor.forClass(
                Wrapper.class);
        verify(zixiangMapper).update(isNull(), captor.capture());
        LambdaUpdateWrapper<?> update = (LambdaUpdateWrapper<?>) captor.getValue();
        assertTrue(update.getSqlSet().contains("fenpei_bumen_id"));
        assertTrue(update.getSqlSet().contains("fenpei_bumen_fuzeren"));
        assertTrue(update.getSqlSet().contains("fenpei_riqi"));
        assertTrue(update.getSqlSet().contains("biz_status"));
        assertTrue(update.getExpression().getNormal().getSqlSegment().contains("f_foreign_id"));
        assertTrue(update.getExpression().getNormal().getSqlSegment().contains("f_delete_mark"));
        assertTrue(update.getParamNameValuePairs().containsValue("plan-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("dept-1"));
        assertTrue(update.getParamNameValuePairs().containsValue("user-1"));
        assertTrue(update.getParamNameValuePairs().containsValue(assignedAt));
        assertTrue(update.getParamNameValuePairs().containsValue("daizhixing"));
    }
 
    @Test
    void reassignsMatchingChildrenFromOtherPlansWithoutDeletingThem() throws Exception {
        DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper = mock(DmsWenjianFushenJihuaFenpeiMapper.class);
        DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper = mock(
                DmsWenjianFushenJihuaFenpeiZixiangMapper.class);
        Date assignedAt = new Date();
        when(fenpeiMapper.selectOne(any())).thenReturn(fenpei("dept-1", "owner-1", assignedAt));
        Date huiguShixian = new Date();
        when(zixiangMapper.selectList(any())).thenReturn(
                Arrays.asList(child("new-detail-1", "file-1", huiguShixian)),
                Arrays.asList(child("existing-detail-1", "file-1", huiguShixian)));
        DmsWenjianFushenJihuaFenpeiSyncService service = service(fenpeiMapper, zixiangMapper);
 
        service.sync("plan-1");
 
        ArgumentCaptor<Wrapper<DmsWenjianFushenJihuaFenpeiZixiangEntity>> captor = ArgumentCaptor.forClass(
                Wrapper.class);
        verify(zixiangMapper, org.mockito.Mockito.times(2)).update(isNull(), captor.capture());
        List<Wrapper<DmsWenjianFushenJihuaFenpeiZixiangEntity>> updates = captor.getAllValues();
        LambdaUpdateWrapper<?> reassignmentUpdate = (LambdaUpdateWrapper<?>) updates.get(0);
        assertTrue(reassignmentUpdate.getSqlSet().contains("huigu_ren"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("fenpei_bumen_id"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("fenpei_bumen_fuzeren"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("fenpei_riqi"));
        assertTrue(reassignmentUpdate.getSqlSet().contains("biz_status"));
        assertTrue(reassignmentUpdate.getExpression().getNormal().getSqlSegment().contains("f_id"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("existing-detail-1"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("dept-1"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("owner-1"));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue(assignedAt));
        assertTrue(reassignmentUpdate.getParamNameValuePairs().containsValue("daizhixing"));
        verify(zixiangMapper).deleteById("new-detail-1");
    }
 
    @Test
    void doesNotUpdateChildrenWhenThePlanDoesNotExist() {
        DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper = mock(DmsWenjianFushenJihuaFenpeiMapper.class);
        DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper = mock(
                DmsWenjianFushenJihuaFenpeiZixiangMapper.class);
        when(fenpeiMapper.selectOne(any())).thenReturn(null);
        DmsWenjianFushenJihuaFenpeiSyncService service = service(fenpeiMapper, zixiangMapper);
 
        DataException error = assertThrows(DataException.class, () -> service.sync("missing-plan"));
 
        assertEquals("未找到文件复审计划分配记录:f_id=missing-plan", error.getMessage());
        verify(zixiangMapper, never()).update(any(), any());
    }
 
    private DmsWenjianFushenJihuaFenpeiSyncService service(
            DmsWenjianFushenJihuaFenpeiMapper fenpeiMapper,
            DmsWenjianFushenJihuaFenpeiZixiangMapper zixiangMapper) {
        return new DmsWenjianFushenJihuaFenpeiSyncServiceImpl(fenpeiMapper, zixiangMapper);
    }
 
    private DmsWenjianFushenJihuaFenpeiEntity fenpei(String departmentId, String owner, Date assignedAt) {
        DmsWenjianFushenJihuaFenpeiEntity result = new DmsWenjianFushenJihuaFenpeiEntity();
        result.setFenpeiBumenId(departmentId);
        result.setFenpeiBumenFuzeren(owner);
        result.setFenpeiRiqi(assignedAt);
        return result;
    }
 
    private DmsWenjianFushenJihuaFenpeiZixiangEntity child(String id, String wenjianId, Date huiguShixian) {
        DmsWenjianFushenJihuaFenpeiZixiangEntity result = new DmsWenjianFushenJihuaFenpeiZixiangEntity();
        result.setId(id);
        result.setWenjianId(wenjianId);
        result.setHuiguShixian(huiguShixian);
        return result;
    }
 
    private void initTableInfo(Class<?> entityClass) {
        if (TableInfoHelper.getTableInfo(entityClass) == null) {
            TableInfoHelper.initTableInfo(new MapperBuilderAssistant(new Configuration(), ""), entityClass);
        }
    }
}