package cn.iocoder.yudao.module.mes.service.pro.bagcode;
|
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.pallet.vo.*;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.batch.vo.MesProBatchPreGenerateReqVO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.pallet.MesProPalletDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.batch.MesProBatchDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.pallet.MesProPalletMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.batch.MesProBatchMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeMapper;
|
import cn.iocoder.yudao.module.mes.dal.redis.MesCodeRedisDAO;
|
import cn.iocoder.yudao.module.mes.service.pro.pallet.MesProPalletServiceImpl;
|
import cn.iocoder.yudao.module.mes.service.pro.batch.MesProBatchServiceImpl;
|
import cn.iocoder.yudao.module.mes.framework.qrcode.MesProQrLabelBuilder;
|
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 java.util.Collection;
|
import java.util.concurrent.atomic.AtomicLong;
|
import static org.junit.jupiter.api.Assertions.*;
|
import static org.mockito.Mockito.*;
|
|
class PalletBatchBusinessCodeTest {
|
private final MesProPalletServiceImpl palletService = new MesProPalletServiceImpl();
|
private final MesProBatchServiceImpl batchService = new MesProBatchServiceImpl();
|
private final MesProPalletMapper pallets = mock(MesProPalletMapper.class);
|
private final MesProBatchMapper batches = mock(MesProBatchMapper.class);
|
private final MesProBagCodeMapper bags = mock(MesProBagCodeMapper.class);
|
private final MesCodeRedisDAO codes = mock(MesCodeRedisDAO.class);
|
|
@BeforeEach void setup() {
|
ReflectionTestUtils.setField(palletService, "palletMapper", pallets);
|
ReflectionTestUtils.setField(palletService, "batchMapper", batches);
|
ReflectionTestUtils.setField(palletService, "bagCodeMapper", bags);
|
ReflectionTestUtils.setField(palletService, "codeRedisDao", codes);
|
ReflectionTestUtils.setField(palletService,"integrityService",mock(cn.iocoder.yudao.module.mes.service.trace.integrity.MesTraceIntegrityService.class));
|
ReflectionTestUtils.setField(batchService, "batchMapper", batches);
|
ReflectionTestUtils.setField(batchService, "codeRedisDao", codes);
|
AtomicLong sequence = new AtomicLong(1000000000000000L);
|
when(codes.generate()).thenAnswer(invocation -> String.valueOf(sequence.incrementAndGet()));
|
}
|
|
@Test void preGeneratedPalletsAndBatchesAlreadyHaveIndependentBusinessCodes() {
|
var palletReq = new MesProPalletPreGenerateReqVO(); palletReq.setCount(2);
|
var batchReq = new MesProBatchPreGenerateReqVO(); batchReq.setCount(2);
|
var values = new java.util.HashSet<String>();
|
palletService.preGeneratePallet(palletReq).forEach(record -> {
|
assertTrue(values.add(record.getTempCode())); assertTrue(values.add(record.getBusinessCode()));
|
});
|
batchService.preGenerateBatch(batchReq).forEach(record -> {
|
assertTrue(values.add(record.getTempCode())); assertTrue(values.add(record.getBusinessCode()));
|
});
|
assertEquals(8, values.size());
|
assertTrue(values.stream().allMatch(code -> code.matches("[0-9]{16}")));
|
verify(pallets).insertBatch(anyCollection());
|
verify(batches, times(2)).insert(any(MesProBatchDO.class));
|
// 预生成只能写入新记录，不应读取或截取数据库中的旧临时码。
|
verifyNoMoreInteractions(pallets, batches);
|
}
|
|
@Test @SuppressWarnings({"unchecked", "rawtypes"})
|
void directPalletCreationCreatesBothCodes() {
|
when(batches.selectById(2L)).thenReturn(new MesProBatchDO().setId(2L).setCode("batch").setStatus(20));
|
var req = new MesProPalletBatchCreateReqVO(); req.setBatchId(2L); req.setCount(1);
|
palletService.batchCreatePallet(req);
|
ArgumentCaptor<Collection<MesProPalletDO>> saved = ArgumentCaptor.forClass((Class) Collection.class);
|
verify(pallets).insertBatch(saved.capture());
|
var pallet = saved.getValue().iterator().next();
|
assertNotNull(pallet.getBusinessCode()); assertNotEquals(pallet.getCode(), pallet.getBusinessCode());
|
}
|
|
@Test void batchBindingKeepsBusinessCodeAndCopiesActualFormalCodeToBags() {
|
var pallet = new MesProPalletDO().setId(1L).setItemId(3L).setTempCode("1111111111111111").setBusinessCode("2222222222222222").setStatus(10);
|
when(pallets.selectByIdForUpdate(1L)).thenReturn(pallet);
|
when(batches.selectByIdForUpdate(2L)).thenReturn(new MesProBatchDO().setId(2L).setCode("BATCH").setStatus(20));
|
var req = new MesProPalletBindBatchReqVO(); req.setBatchId(2L); req.setIds(List.of(1L));
|
palletService.bindBatch(req);
|
var update = ArgumentCaptor.forClass(MesProPalletDO.class);
|
verify(pallets).updateById(update.capture());
|
assertNull(update.getValue().getBusinessCode()); // MyBatis ignores null fields, so stable business code is retained.
|
assertEquals("2222222222222222", pallet.getBusinessCode());
|
verify(bags).updatePalletCodeByPalletId(1L, update.getValue().getCode());
|
}
|
|
@Test void supplementationNeverChangesPreviouslyIssuedPalletOrBatchCode() {
|
when(pallets.selectByIdForUpdate(1L)).thenReturn(new MesProPalletDO().setId(1L).setStatus(10).setBusinessCode("1111111111111111"));
|
when(batches.selectByIdForUpdate(2L)).thenReturn(new MesProBatchDO().setId(2L).setStatus(20).setBusinessCode("2222222222222222"));
|
assertEquals(0, palletService.generateBusinessCodes(List.of(1L, 1L)));
|
assertEquals(0, batchService.generateBusinessCodes(List.of(2L)));
|
verifyNoInteractions(codes);
|
verify(pallets, never()).updateById(any(MesProPalletDO.class));
|
verify(batches, never()).updateById(any(MesProBatchDO.class));
|
}
|
|
@Test void supplementationRejectsCanceledAndMissingBeforeWritingAnyCode() {
|
when(pallets.selectByIdForUpdate(1L)).thenReturn(new MesProPalletDO().setId(1L).setStatus(10));
|
when(pallets.selectByIdForUpdate(2L)).thenReturn(new MesProPalletDO().setId(2L).setStatus(20));
|
when(batches.selectByIdForUpdate(1L)).thenReturn(new MesProBatchDO().setId(1L).setStatus(40));
|
assertThrows(ServiceException.class, () -> palletService.generateBusinessCodes(List.of(1L, 2L)));
|
assertThrows(ServiceException.class, () -> batchService.generateBusinessCodes(List.of(1L)));
|
assertThrows(ServiceException.class, () -> batchService.generateBusinessCodes(List.of(3L)));
|
verifyNoInteractions(codes);
|
verify(pallets, never()).updateById(any(MesProPalletDO.class));
|
}
|
|
@Test void publicQueryRemainsSeparateFromInternalBusinessQuery() {
|
palletService.getPalletByCode("old"); batchService.getBatchByCode("old");
|
verify(pallets).selectByCode("old"); verify(pallets).selectByTempCode("old");
|
verify(batches).selectByCode("old"); verify(batches).selectByTempCode("old");
|
palletService.getPalletByScanCode("business"); batchService.getBatchByScanCode("business");
|
verify(pallets).selectByScanCode("business"); verify(batches).selectByScanCode("business");
|
assertEquals("1111111111111111", MesProQrLabelBuilder.buildPalletBusinessCodeLabel(
|
new MesProPalletDO().setBusinessCode("1111111111111111")).getCode());
|
assertEquals("2222222222222222", MesProQrLabelBuilder.buildBatchBusinessCodeLabel(
|
new MesProBatchDO().setBusinessCode("2222222222222222")).getCode());
|
}
|
}
|
