package cn.iocoder.yudao.module.mes.service.pro.bagcode;
|
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
|
import cn.iocoder.yudao.module.mdm.api.unit.MdmUnitMeasureApi;
|
import cn.iocoder.yudao.module.mdm.api.unit.dto.MdmUnitMeasureRespDTO;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.bagcode.vo.*;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.mdm.MesMdmItemDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.bagcode.MesProBagCodeDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.batch.MesProBatchDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.pallet.MesProPalletDO;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeGenerateTaskMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.bagcode.MesProBagCodeReplaceMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.batch.MesProBatchMapper;
|
import cn.iocoder.yudao.module.mes.dal.redis.MesCodeRedisDAO;
|
import cn.iocoder.yudao.module.mes.framework.bagcode.MesProBagCodeGenerateProperties;
|
import cn.iocoder.yudao.module.mes.framework.qrcode.MesProQrLabelBuilder;
|
import cn.iocoder.yudao.module.mes.framework.qrcode.QrCodeImageUtils;
|
import cn.iocoder.yudao.module.mes.service.mdm.MesMdmItemService;
|
import cn.hutool.extra.qrcode.QrCodeUtil;
|
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.ArrayList;
|
import java.util.Collection;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.concurrent.atomic.AtomicLong;
|
import static org.junit.jupiter.api.Assertions.*;
|
import static org.mockito.Mockito.*;
|
|
class BagBusinessCodeTest {
|
private final MesProBagCodeServiceImpl service = new MesProBagCodeServiceImpl();
|
private final MesProBagCodeMapper bags = mock(MesProBagCodeMapper.class);
|
private final MesCodeRedisDAO codes = mock(MesCodeRedisDAO.class);
|
private final MesMdmItemService items = mock(MesMdmItemService.class);
|
private final MesProBatchMapper batches = mock(MesProBatchMapper.class);
|
private final MesProBagCodeReplaceMapper replacements = mock(MesProBagCodeReplaceMapper.class);
|
private final MdmUnitMeasureApi units = mock(MdmUnitMeasureApi.class);
|
private final MesProBagCodeChunkWriter writer = mock(MesProBagCodeChunkWriter.class);
|
private final MesProBagCodeBatchGenerator generator = new MesProBagCodeBatchGenerator();
|
private final MesProBagCodeGenerateProperties properties = new MesProBagCodeGenerateProperties();
|
|
@BeforeEach void setup() {
|
ReflectionTestUtils.setField(service, "bagCodeMapper", bags);
|
ReflectionTestUtils.setField(service, "codeRedisDao", codes);
|
ReflectionTestUtils.setField(service, "mdmItemService", items);
|
ReflectionTestUtils.setField(service, "batchMapper", batches);
|
ReflectionTestUtils.setField(service, "replaceMapper", replacements);
|
ReflectionTestUtils.setField(service, "unitMeasureApi", units);
|
ReflectionTestUtils.setField(service, "batchGenerator", generator);
|
ReflectionTestUtils.setField(service, "generateProperties", properties);
|
ReflectionTestUtils.setField(service, "generateCleaner", mock(MesProBagCodeGenerateCleaner.class));
|
ReflectionTestUtils.setField(service, "generateTaskService", mock(MesProBagCodeGenerateTaskService.class));
|
// 分段执行器使用真实实现，仅把事务写入器与 Redis 取码替换为 mock
|
ReflectionTestUtils.setField(generator, "bagCodeMapper", bags);
|
ReflectionTestUtils.setField(generator, "taskMapper", mock(MesProBagCodeGenerateTaskMapper.class));
|
ReflectionTestUtils.setField(generator, "codeRedisDao", codes);
|
ReflectionTestUtils.setField(generator, "chunkWriter", writer);
|
ReflectionTestUtils.setField(generator, "properties", properties);
|
doAnswer(invocation -> {
|
bags.insertBatch(invocation.getArgument(0));
|
return null;
|
}).when(writer).insertBagCodes(anyList());
|
doAnswer(invocation -> {
|
List<MesProPalletDO> pallets = invocation.getArgument(0);
|
for (int i = 0; i < pallets.size(); i++) {
|
pallets.get(i).setId((long) (i + 1));
|
}
|
return null;
|
}).when(writer).insertPallets(anyList());
|
|
when(items.validateItemExists(1L)).thenReturn(new MesMdmItemDO().setId(1L).setUnitMeasureId(2L));
|
AtomicLong sequence = new AtomicLong(1000000000000000L);
|
when(codes.generate()).thenAnswer(invocation -> String.valueOf(sequence.incrementAndGet()));
|
when(codes.generateBatch(anyInt())).thenAnswer(invocation -> {
|
int count = invocation.getArgument(0);
|
List<String> codes = new ArrayList<>(count);
|
for (int i = 0; i < count; i++) {
|
codes.add(String.valueOf(sequence.incrementAndGet()));
|
}
|
return codes;
|
});
|
when(codes.allocateBagNoStart(anyInt(), any())).thenReturn(1);
|
}
|
|
@Test void rawGenerationCreatesDistinctPairsInSameRecords() {
|
MesProBagCodeRawGenerateReqVO req = new MesProBagCodeRawGenerateReqVO();
|
req.setItemId(1L); req.setCount(2);
|
service.generateRawBagCodes(req);
|
assertDistinctPairs(2);
|
}
|
|
@Test void dataPackageGenerationCreatesBusinessCodes() {
|
when(units.getUnitMeasure(2L)).thenReturn(CommonResult.success(new MdmUnitMeasureRespDTO().setType("吨")));
|
MesProBagCodeGenerateReqVO req = new MesProBagCodeGenerateReqVO();
|
req.setItemId(1L); req.setBagCount(2);
|
service.generateBagCodes(req);
|
assertDistinctPairs(2);
|
}
|
|
@Test @SuppressWarnings({"unchecked", "rawtypes"}) void automaticPalletCarriesVariety() {
|
when(units.getUnitMeasure(2L)).thenReturn(CommonResult.success(new MdmUnitMeasureRespDTO().setType("48袋")));
|
var req=new MesProBagCodeGenerateReqVO();req.setItemId(1L);req.setPalletCount(1);
|
service.generateBagCodes(req);
|
ArgumentCaptor<List<MesProPalletDO>> saved=ArgumentCaptor.forClass((Class)List.class);
|
verify(writer).insertPallets(saved.capture());assertEquals(1L,saved.getValue().iterator().next().getItemId());
|
}
|
|
@Test void replacementIssuesNewPairInsteadOfReusingOldBusinessCode() {
|
when(batches.selectByIdForUpdate(2L)).thenReturn(new MesProBatchDO().setId(2L).setStatus(20));
|
when(bags.selectListByIdsForUpdate(List.of(1L))).thenReturn(List.of(new MesProBagCodeDO()
|
.setId(1L).setBatchId(2L).setStatus(10).setCode("9999999999999999").setBusinessCode("8888888888888888")));
|
when(bags.cancelById(eq(1L), eq(10), eq(30), any(), any())).thenReturn(1);
|
MesProBagCodeReplaceReqVO req = new MesProBagCodeReplaceReqVO();
|
req.setBatchId(2L); req.setOldIds(List.of(1L)); req.setReason("破损");
|
service.replaceBagCodes(req);
|
assertDistinctPairs(1);
|
}
|
|
@Test void supplementationLocksAndNeverChangesExistingCode() {
|
when(bags.selectListByIdsForUpdate(List.of(1L, 2L))).thenReturn(List.of(
|
new MesProBagCodeDO().setId(1L).setStatus(10),
|
new MesProBagCodeDO().setId(2L).setStatus(20).setBusinessCode("8888888888888888")));
|
assertEquals(1, service.generateBusinessCodes(List.of(2L, 1L, 1L)));
|
ArgumentCaptor<MesProBagCodeDO> update = ArgumentCaptor.forClass(MesProBagCodeDO.class);
|
verify(bags).updateById(update.capture());
|
assertEquals(1L, update.getValue().getId());
|
assertNull(update.getValue().getCode());
|
assertNotNull(update.getValue().getBusinessCode());
|
when(bags.selectListByIdsForUpdate(List.of(1L))).thenReturn(List.of(update.getValue().setStatus(10)));
|
assertEquals(0, service.generateBusinessCodes(List.of(1L)));
|
verify(codes, times(1)).generate();
|
}
|
|
@Test void canceledOrMissingBagCannotBeSupplemented() {
|
when(bags.selectListByIdsForUpdate(List.of(1L))).thenReturn(List.of(new MesProBagCodeDO().setId(1L).setStatus(30)));
|
assertThrows(ServiceException.class, () -> service.generateBusinessCodes(List.of(1L)));
|
assertThrows(ServiceException.class, () -> service.generateBusinessCodes(List.of(2L)));
|
verifyNoInteractions(codes);
|
verify(bags, never()).updateById(any(MesProBagCodeDO.class));
|
}
|
|
@Test void publicLookupUsesTraceColumnAndInternalLookupUsesBoth() {
|
service.getBagCodeByCode("1111111111111111");
|
verify(bags).selectByCode("1111111111111111");
|
service.getBagCodeByScanCode("2222222222222222");
|
verify(bags).selectByScanCode("2222222222222222");
|
}
|
|
@Test void businessQrEncodesStoredValueAndRejectsMissingCode() {
|
var label = MesProQrLabelBuilder.buildBagBusinessCodeLabel(new MesProBagCodeDO()
|
.setCode("9999999999999999").setBusinessCode("8888888888888888"));
|
assertEquals("8888888888888888", QrCodeUtil.decode(QrCodeImageUtils.createQrLabel(label.getCode(), label.getFileName())));
|
assertThrows(ServiceException.class, () -> MesProQrLabelBuilder.buildBagBusinessCodeLabel(new MesProBagCodeDO()));
|
}
|
|
@SuppressWarnings({"unchecked", "rawtypes"})
|
private void assertDistinctPairs(int count) {
|
ArgumentCaptor<Collection<MesProBagCodeDO>> saved = ArgumentCaptor.forClass((Class) Collection.class);
|
verify(bags).insertBatch(saved.capture());
|
assertEquals(count, saved.getValue().size());
|
var values = new HashSet<String>();
|
for (MesProBagCodeDO bag : saved.getValue()) {
|
assertTrue(bag.getBusinessCode().matches("[0-9]{16}"));
|
assertTrue(values.add(bag.getCode())); assertTrue(values.add(bag.getBusinessCode()));
|
}
|
}
|
}
|
