refactor(mes): 重构质量管理和批次绑定功能

云

6 小时以前 5072520172e8f45e3ccb8afc26cf0c8186ba4cdd

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
package cn.iocoder.yudao.module.mes.service.qc.seedquality;
 
import cn.iocoder.yudao.module.mes.dal.dataobject.qc.seedquality.MesQcSeedQualityDO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityRetestReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.qc.seedquality.vo.MesQcSeedQualityBatchRetestReqVO;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.seedquality.MesQcSeedQualityActionMapper;
import cn.iocoder.yudao.module.mes.dal.mysql.qc.seedquality.MesQcSeedQualityMapper;
import cn.iocoder.yudao.module.mes.service.qc.approver.MesQcApproverService;
import cn.iocoder.yudao.module.mes.service.wm.transaction.MesWmTransactionService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;
import java.util.List;
 
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
 
class SeedQualityWorkflowTest {
    private final MesQcSeedQualityServiceImpl service = new MesQcSeedQualityServiceImpl();
    private final MesQcSeedQualityMapper qualityMapper = mock(MesQcSeedQualityMapper.class);
    private final MesQcSeedQualityActionMapper actionMapper = mock(MesQcSeedQualityActionMapper.class);
    private final MesWmTransactionService transactionService = mock(MesWmTransactionService.class);
    private final MesQcApproverService approverService = mock(MesQcApproverService.class);
 
    @BeforeEach
    void setUp() {
        ReflectionTestUtils.setField(service, "qualityMapper", qualityMapper);
        ReflectionTestUtils.setField(service, "actionMapper", actionMapper);
        ReflectionTestUtils.setField(service, "wmTransactionService", transactionService);
        ReflectionTestUtils.setField(service, "approverService", approverService);
    }
 
    @Test
    void initialApprovalOnlyQueuesRetestAndFailedRetestCanReturnToRetest() {
        when(qualityMapper.selectByIdForUpdate(1L)).thenReturn(
                MesQcSeedQualityDO.builder().id(1L).code("B1").result(2).workflowStatus(20).build(),
                MesQcSeedQualityDO.builder().id(1L).code("B1").result(2).workflowStatus(60).build());
        service.processApprove(1L, true, "");
        verifyNoInteractions(transactionService);
        service.companyApprove(1L, false, "复检不合格，重新取样");
        ArgumentCaptor<MesQcSeedQualityDO> update = ArgumentCaptor.forClass(MesQcSeedQualityDO.class);
        verify(qualityMapper, times(2)).updateById(update.capture());
        assertEquals(10, update.getAllValues().get(0).getWorkflowStatus());
        assertEquals(10, update.getAllValues().get(1).getWorkflowStatus());
        verifyNoInteractions(transactionService);
    }
 
    @Test
    void rejectedInitialInspectionNeedsRecheck() {
        when(qualityMapper.selectByIdForUpdate(1L)).thenReturn(
                MesQcSeedQualityDO.builder().id(1L).code("B1").result(2).workflowStatus(25).build());
        service.processApprove(1L, false, "初检样本无效，重新检测");
        ArgumentCaptor<MesQcSeedQualityDO> update = ArgumentCaptor.forClass(MesQcSeedQualityDO.class);
        verify(qualityMapper).updateById(update.capture());
        assertEquals(50, update.getValue().getWorkflowStatus());
        verifyNoInteractions(transactionService);
    }
 
    @Test
    void rejectionRequiresOpinion() {
        when(qualityMapper.selectByIdForUpdate(1L)).thenReturn(
                MesQcSeedQualityDO.builder().id(1L).workflowStatus(20).build());
        assertEquals("驳回时请填写审批意见", assertThrows(IllegalArgumentException.class,
                () -> service.processApprove(1L, false, " ")).getMessage());
        verify(qualityMapper, never()).updateById(any(MesQcSeedQualityDO.class));
        verifyNoInteractions(actionMapper, transactionService);
    }
 
    @Test
    void cannotRetestBeforeInitialReview() {
        when(qualityMapper.selectByIdForUpdate(1L)).thenReturn(
                MesQcSeedQualityDO.builder().id(1L).code("B1").workflowStatus(25).build());
        assertThrows(IllegalArgumentException.class,
                () -> service.retest(1L, new MesQcSeedQualityRetestReqVO()));
        verify(qualityMapper, never()).updateById(any(MesQcSeedQualityDO.class));
        verifyNoInteractions(transactionService, actionMapper);
    }
 
    @Test
    void batchRetestRejectsDifferentProductionBatchesBeforeAnyWrite() {
        when(qualityMapper.selectByIdForUpdate(1L)).thenReturn(
                MesQcSeedQualityDO.builder().id(1L).code("B1").batchCode("A").workflowStatus(10).build());
        when(qualityMapper.selectByIdForUpdate(2L)).thenReturn(
                MesQcSeedQualityDO.builder().id(2L).code("B2").batchCode("B").workflowStatus(10).build());
        MesQcSeedQualityBatchRetestReqVO request = new MesQcSeedQualityBatchRetestReqVO();
        request.setIds(List.of(1L, 2L));
        assertThrows(IllegalArgumentException.class, () -> service.retestBatch(request));
        verify(qualityMapper, never()).updateById(any(MesQcSeedQualityDO.class));
        verifyNoInteractions(transactionService, actionMapper);
    }
 
    @Test
    void skipsApprovalWhenStatusChanged() {
        when(qualityMapper.selectByIdForUpdate(1L)).thenReturn(
                MesQcSeedQualityDO.builder().id(1L).workflowStatus(40).build());
        assertThrows(IllegalArgumentException.class, () -> service.companyApprove(1L, true, "重复审批"));
        verify(qualityMapper, never()).updateById(any(MesQcSeedQualityDO.class));
        verifyNoInteractions(transactionService, actionMapper);
    }
}