package cn.iocoder.yudao.module.mes.service.pro.task.schedule;
|
|
import cn.iocoder.yudao.framework.common.exception.ServiceException;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.mes.controller.admin.pro.task.vo.*;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.item.MesMdItemDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkstationDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.process.MesProProcessDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.route.MesProRouteDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.task.MesProTaskDO;
|
import cn.iocoder.yudao.module.mes.dal.dataobject.pro.workorder.*;
|
import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.task.MesProTaskMapper;
|
import cn.iocoder.yudao.module.mes.dal.mysql.pro.workorder.MesProWorkOrderMapper;
|
import cn.iocoder.yudao.module.mes.service.cal.holiday.MesCalHolidayService;
|
import cn.iocoder.yudao.module.mes.service.md.item.MesMdItemService;
|
import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkstationService;
|
import cn.iocoder.yudao.module.mes.service.pro.process.MesProProcessService;
|
import cn.iocoder.yudao.module.mes.service.pro.route.MesProRouteService;
|
import cn.iocoder.yudao.module.mes.service.pro.task.MesProTaskService;
|
import cn.iocoder.yudao.module.mes.service.pro.workorder.MesProWorkOrderProcessService;
|
import org.junit.jupiter.api.Test;
|
import org.springframework.aop.framework.ProxyFactory;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
import org.springframework.jdbc.datasource.*;
|
import org.springframework.test.util.ReflectionTestUtils;
|
import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
|
import org.springframework.transaction.interceptor.TransactionInterceptor;
|
import org.springframework.dao.DataAccessException;
|
|
import java.lang.reflect.*;
|
import java.math.BigDecimal;
|
import java.time.*;
|
import java.util.*;
|
import java.util.concurrent.*;
|
import java.util.concurrent.atomic.AtomicInteger;
|
import static org.junit.jupiter.api.Assertions.*;
|
|
class MesProBatchScheduleServiceTest {
|
@Test void yieldAdjustedPreviewExecutesThroughRealQuantityGuard() {
|
var f = new Fixture();
|
f.processes.forEach(process -> process.setYieldRate(new BigDecimal("0.98")));
|
var request = f.confirmable();
|
assertEquals(2, f.proxy.execute(request).size());
|
assertEquals(new BigDecimal("103.00"), f.readTasks().getFirst().getQuantity());
|
assertEquals(new BigDecimal("100.00"), f.readTasks().getLast().getQuantity());
|
assertEquals(new BigDecimal("100.00"), f.scheduledQuantity());
|
assertFalse(f.service.preview(f.request()).isCanExecute());
|
}
|
@Test void previewDoesNotWriteAndProcessesAreSequential() {
|
var f = new Fixture();
|
var result = f.service.preview(f.request());
|
assertTrue(result.isCanExecute());
|
assertEquals(2, result.getTasks().size());
|
assertFalse(result.getTasks().get(1).getStartTime().isBefore(result.getTasks().getFirst().getEndTime()));
|
assertEquals(0, f.taskCount());
|
assertEquals(0, f.creates.get());
|
}
|
|
@Test void partialOrderOnlyFillsEachProcessRemainingQuantity() {
|
var f = new Fixture();
|
f.jdbc.update("INSERT INTO schedule_task VALUES(99,1,1,1,40,4,?,?)", LocalDateTime.now().minusDays(1), LocalDateTime.now().minusHours(1));
|
var preview = f.service.preview(f.request());
|
assertTrue(preview.isCanExecute());
|
assertEquals(new BigDecimal("60.00"), preview.getTasks().getFirst().getQuantity());
|
assertEquals(new BigDecimal("100"), preview.getTasks().getLast().getQuantity());
|
}
|
|
@Test void completedSchedulingBlocksDuplicateAndCanceledDoesNotConsumeQuantity() {
|
var f = new Fixture();
|
var request = f.confirmable();
|
f.proxy.execute(request);
|
assertThrows(ServiceException.class, () -> f.proxy.execute(request));
|
assertEquals(2, f.taskCount());
|
assertEquals(new BigDecimal("100.00"), f.scheduledQuantity());
|
}
|
|
@Test void anyInvalidOrderBlocksWholeBatch() {
|
var f = new Fixture();
|
f.orders.add(new MesProWorkOrderDO().setId(2L).setCode("WO-2").setStatus(0).setType(1).setQuantity(BigDecimal.TEN));
|
f.jdbc.update("INSERT INTO schedule_order VALUES(2,0)");
|
var request = f.request(); request.setWorkOrderIds(List.of(1L, 2L));
|
var preview = f.service.preview(request);
|
assertFalse(preview.isCanExecute());
|
assertNotNull(preview.getOrders().getLast().getError());
|
request.setPreviewTime(preview.getPreviewTime()); request.setPreviewHash(preview.getPreviewHash());
|
assertThrows(ServiceException.class, () -> f.proxy.execute(request));
|
assertEquals(0, f.taskCount());
|
}
|
|
@Test void missingCapacityAndDisabledOrderDoNotSilentlyCreateDraftTasks() {
|
var f = new Fixture();
|
f.machines.getFirst().setProductionEfficiency(BigDecimal.ZERO);
|
assertFalse(f.service.preview(f.request()).isCanExecute());
|
assertEquals(0, f.taskCount());
|
f.machines.getFirst().setProductionEfficiency(BigDecimal.valueOf(100));
|
f.orders.getFirst().setStatus(2);
|
assertFalse(f.service.preview(f.request()).isCanExecute());
|
}
|
|
@Test void changedPreviewAndExpiredPreviewCannotCommit() {
|
var f = new Fixture(); var request = f.confirmable();
|
f.machines.getFirst().setProductionEfficiency(BigDecimal.valueOf(200));
|
assertThrows(ServiceException.class, () -> f.proxy.execute(request));
|
assertEquals(0, f.taskCount());
|
final var expired = f.confirmable(); expired.setPreviewTime(LocalDateTime.now(ZoneId.of("Asia/Shanghai")).minusMinutes(16));
|
assertThrows(ServiceException.class, () -> f.proxy.execute(expired));
|
}
|
|
@Test void duplicateIdsAndInvalidClockAreRejected() {
|
var f = new Fixture(); var request = f.request(); request.setWorkOrderIds(List.of(1L, 1L));
|
assertThrows(ServiceException.class, () -> f.service.preview(request));
|
request.setWorkOrderIds(List.of(1L)); request.setStartTime(LocalDateTime.now().minusDays(1));
|
assertThrows(ServiceException.class, () -> f.service.preview(request));
|
}
|
|
@Test void failureDuringSecondTaskRollsBackTasksAndOrderCounter() {
|
var f = new Fixture(); var request = f.confirmable(); f.failAt = 2;
|
assertThrows(IllegalStateException.class, () -> f.proxy.execute(request));
|
assertEquals(0, f.taskCount());
|
assertEquals(BigDecimal.ZERO.setScale(2), f.scheduledQuantity());
|
}
|
|
@Test void concurrentSubmissionsCannotCreateDuplicateTasks() throws Exception {
|
var f = new Fixture(); var request = f.confirmable();
|
var start = new CountDownLatch(1);
|
try (var pool = Executors.newFixedThreadPool(2)) {
|
Callable<Boolean> action = () -> {
|
start.await();
|
try { f.proxy.execute(request); return true; }
|
catch (ServiceException | DataAccessException expected) { return false; }
|
};
|
var first = pool.submit(action); var second = pool.submit(action); start.countDown();
|
int successes = (first.get(20, TimeUnit.SECONDS) ? 1 : 0) + (second.get(20, TimeUnit.SECONDS) ? 1 : 0);
|
assertEquals(1, successes); assertEquals(2, f.taskCount());
|
}
|
}
|
|
@Test void latenessRequiresExplicitAcknowledgment() {
|
var f = new Fixture(); f.orders.getFirst().setRequestDate(LocalDateTime.now().minusDays(1));
|
var request = f.confirmable(); request.setAllowLate(false);
|
assertThrows(ServiceException.class, () -> f.proxy.execute(request));
|
assertEquals(0, f.taskCount());
|
request.setAllowLate(true); assertEquals(2, f.proxy.execute(request).size());
|
}
|
|
@Test void preparationAndWaitingAreReserved() {
|
var f = new Fixture();
|
f.processes.getFirst().setPrepareTime(30).setWaitTime(60);
|
var preview = f.service.preview(f.request());
|
assertTrue(preview.isCanExecute());
|
assertEquals(2, preview.getTasks().getFirst().getDuration());
|
assertFalse(preview.getTasks().getLast().getStartTime().isBefore(preview.getTasks().getFirst().getEndTime().plusHours(1)));
|
}
|
|
@Test void canceledTasksDoNotConsumeQuantity() {
|
var f = new Fixture();
|
f.jdbc.update("INSERT INTO schedule_task VALUES(99,1,1,1,100,5,?,?)", LocalDateTime.now().minusDays(1), LocalDateTime.now().minusHours(1));
|
var preview = f.service.preview(f.request());
|
assertTrue(preview.isCanExecute()); assertEquals(new BigDecimal("100"), preview.getTasks().getFirst().getQuantity());
|
}
|
|
@Test void selectedChildIsScheduledBeforeParent() {
|
var f = new Fixture();
|
f.orders.add(new MesProWorkOrderDO().setId(2L).setCode("CHILD").setParentId(1L).setStatus(1).setType(1)
|
.setRouteId(100L).setProductId(1000L).setQuantity(BigDecimal.TEN));
|
var request = f.request(); request.setWorkOrderIds(List.of(1L, 2L));
|
var preview = f.service.preview(request);
|
assertTrue(preview.isCanExecute());
|
assertEquals(2L, preview.getTasks().getFirst().getWorkOrderId());
|
assertFalse(preview.getTasks().get(2).getStartTime().isBefore(preview.getTasks().get(1).getEndTime()));
|
}
|
|
@Test void unselectedUnfinishedChildAndMultipleOutputsAreBlocked() {
|
var f = new Fixture();
|
f.orders.add(new MesProWorkOrderDO().setId(2L).setCode("CHILD").setParentId(1L).setStatus(1).setType(1));
|
assertFalse(f.service.preview(f.request()).isCanExecute());
|
f.orders.removeLast(); f.processes.getFirst().setOutputItemId("1,2");
|
assertFalse(f.service.preview(f.request()).isCanExecute());
|
}
|
|
@Test void customerPermissionsAreCheckedBeforeShowingOrderData() {
|
var f = new Fixture(); f.orders.getFirst().setClientId(99L);
|
f.set("customerApi", stub(CrmCustomerApi.class, (p,m,a) -> List.of(10L)));
|
var preview = f.service.preview(f.request());
|
assertFalse(preview.isCanExecute()); assertNull(preview.getOrders().getFirst().getWorkOrderCode());
|
}
|
|
private static <T> T stub(Class<T> type, InvocationHandler handler) {
|
return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, (proxy, method, args) -> {
|
if (method.getDeclaringClass() == Object.class) {
|
return switch (method.getName()) {
|
case "toString" -> type.getSimpleName() + "Stub";
|
case "hashCode" -> System.identityHashCode(proxy);
|
case "equals" -> proxy == args[0];
|
default -> throw new AssertionError(method.getName());
|
};
|
}
|
return handler.invoke(proxy, method, args);
|
}));
|
}
|
|
static class Fixture {
|
final JdbcTemplate jdbc;
|
final MesProBatchScheduleService service = new MesProBatchScheduleService();
|
final MesProBatchScheduleService proxy;
|
final AtomicInteger creates = new AtomicInteger();
|
int failAt;
|
final List<MesProWorkOrderDO> orders = new ArrayList<>(List.of(new MesProWorkOrderDO().setId(1L).setCode("WO-1")
|
.setName("测试生产工单").setStatus(1).setType(1).setRouteId(100L).setProductId(1000L).setQuantity(new BigDecimal("100"))));
|
final List<MesProWorkOrderProcessDO> processes = new ArrayList<>(List.of(
|
new MesProWorkOrderProcessDO().setProcessId(1L).setSort(1), new MesProWorkOrderProcessDO().setProcessId(2L).setSort(2)));
|
final List<MesDvMachineryDO> machines = new ArrayList<>(List.of(
|
new MesDvMachineryDO().setId(10L).setName("设备A").setStatus(1).setProductionEfficiency(BigDecimal.valueOf(100)),
|
new MesDvMachineryDO().setId(20L).setName("设备B").setStatus(1).setProductionEfficiency(BigDecimal.valueOf(100))));
|
|
Fixture() {
|
var source = new DriverManagerDataSource("jdbc:h2:mem:schedule_"+UUID.randomUUID()+";DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000", "sa", "");
|
jdbc = new JdbcTemplate(source);
|
jdbc.execute("CREATE TABLE schedule_mutex(id BIGINT PRIMARY KEY)"); jdbc.update("INSERT INTO schedule_mutex VALUES(1)");
|
jdbc.execute("CREATE TABLE schedule_order(id BIGINT PRIMARY KEY, scheduled DECIMAL(14,2))"); jdbc.update("INSERT INTO schedule_order VALUES(1,0)");
|
jdbc.execute("CREATE TABLE schedule_task(id BIGINT PRIMARY KEY, wo BIGINT, process BIGINT, station BIGINT, qty DECIMAL(14,2), status INT, starts TIMESTAMP, ends TIMESTAMP)");
|
var guard = new MesProScheduleGuardService() {
|
@Override public void lock() { jdbc.queryForList("SELECT id FROM schedule_mutex ORDER BY id FOR UPDATE"); }
|
@Override public Map<Long, Set<Long>> machineIdsByStation() { return Map.of(1L, Set.of(10L), 2L, Set.of(20L)); }
|
};
|
set("guard", guard);
|
set("workOrderMapper", stub(MesProWorkOrderMapper.class, (p, m, a) -> switch (m.getName()) {
|
case "selectByIds" -> orders.stream().filter(order -> ((Collection<?>)a[0]).contains(order.getId())).toList();
|
case "lockScheduleOrders" -> { jdbc.queryForList("SELECT id FROM schedule_order ORDER BY id FOR UPDATE"); yield orders; }
|
case "selectList" -> orders.stream().filter(order -> Objects.equals(order.getParentId(), a[1])).toList();
|
case "updateById" -> { var o = (MesProWorkOrderDO)a[0]; yield jdbc.update("UPDATE schedule_order SET scheduled=? WHERE id=?", o.getQuantityScheduled(), o.getId()); }
|
default -> throw new AssertionError(m.getName());
|
}));
|
set("taskMapper", stub(MesProTaskMapper.class, (p, m, a) -> switch (m.getName()) {
|
case "selectSchedulingTasks" -> readTasks().stream().filter(t -> t.getStatus()!=4 && t.getStatus()!=5).toList();
|
case "selectListByWorkOrderIds" -> readTasks().stream().filter(t -> ((Collection<?>)a[0]).contains(t.getWorkOrderId())).toList();
|
default -> throw new AssertionError(m.getName());
|
}));
|
set("workstationService", stub(MesMdWorkstationService.class, (p,m,a) -> List.of(
|
new MesMdWorkstationDO().setId(1L).setName("工作站A").setProcessId(1L).setStatus(0),
|
new MesMdWorkstationDO().setId(2L).setName("工作站B").setProcessId(2L).setStatus(0))));
|
set("machineryMapper", stub(MesDvMachineryMapper.class, (p,m,a) -> machines));
|
set("customerApi", stub(CrmCustomerApi.class, (p,m,a) -> null));
|
set("holidayService", stub(MesCalHolidayService.class, (p,m,a) -> List.of()));
|
set("workOrderProcessService", stub(MesProWorkOrderProcessService.class, (p,m,a) -> processes));
|
var quantities = new MesProScheduleQuantityService();
|
ReflectionTestUtils.setField(quantities, "workOrderProcessService", stub(MesProWorkOrderProcessService.class, (p,m,a) -> processes));
|
ReflectionTestUtils.setField(guard, "quantityService", quantities);
|
ReflectionTestUtils.setField(guard, "taskMapper", stub(MesProTaskMapper.class, (p,m,a) -> switch (m.getName()) {
|
case "selectListByWorkOrderId" -> readTasks().stream().filter(t -> Objects.equals(t.getWorkOrderId(), a[0])).toList();
|
case "selectSchedulingTasks" -> readTasks().stream().filter(t -> t.getStatus()!=4 && t.getStatus()!=5).toList();
|
default -> throw new AssertionError(m.getName());
|
}));
|
set("routeService", stub(MesProRouteService.class, (p,m,a) -> new MesProRouteDO().setId(100L).setName("测试路线").setStatus(0)));
|
set("processService", stub(MesProProcessService.class, (p,m,a) -> m.getName().equals("getProcess")
|
? new MesProProcessDO().setId((Long)a[0]).setName("工序"+a[0]).setStatus(0) : null));
|
set("itemService", stub(MesMdItemService.class, (p,m,a) -> new MesMdItemDO().setId(1000L).setName("测试产品").setStatus(0)));
|
set("taskService", stub(MesProTaskService.class, (p,m,a) -> {
|
assertEquals("createTask", m.getName());
|
int number = creates.incrementAndGet();
|
if (number == failAt) throw new IllegalStateException("模拟参数快照写入失败");
|
var task = (MesProTaskSaveReqVO)a[0];
|
guard.validate(orders.stream().filter(order -> Objects.equals(order.getId(), task.getWorkOrderId())).findFirst().orElseThrow(),
|
new MesProTaskDO().setWorkOrderId(task.getWorkOrderId()).setRouteId(task.getRouteId()).setProcessId(task.getProcessId())
|
.setWorkstationId(task.getWorkstationId()).setQuantity(task.getQuantity()).setStartTime(task.getStartTime()).setEndTime(task.getEndTime()), null);
|
jdbc.update("INSERT INTO schedule_task VALUES(?,?,?,?,?,?,?,?)", number, task.getWorkOrderId(), task.getProcessId(),
|
task.getWorkstationId(), task.getQuantity(), 0, task.getStartTime(), task.getEndTime());
|
return (long)number;
|
}));
|
var factory = new ProxyFactory(service); factory.setProxyTargetClass(true);
|
factory.addAdvice(new TransactionInterceptor(new DataSourceTransactionManager(source), new AnnotationTransactionAttributeSource()));
|
proxy = (MesProBatchScheduleService)factory.getProxy();
|
}
|
void set(String field, Object value) { ReflectionTestUtils.setField(service, field, value); }
|
int taskCount() { return jdbc.queryForObject("SELECT COUNT(*) FROM schedule_task", Integer.class); }
|
BigDecimal scheduledQuantity() { return jdbc.queryForObject("SELECT scheduled FROM schedule_order WHERE id=1", BigDecimal.class); }
|
List<MesProTaskDO> readTasks() { return jdbc.query("SELECT * FROM schedule_task ORDER BY id", (row,n) -> new MesProTaskDO()
|
.setId(row.getLong("id")).setWorkOrderId(row.getLong("wo")).setProcessId(row.getLong("process"))
|
.setWorkstationId(row.getLong("station")).setQuantity(row.getBigDecimal("qty")).setStatus(row.getInt("status"))
|
.setStartTime(row.getTimestamp("starts").toLocalDateTime()).setEndTime(row.getTimestamp("ends").toLocalDateTime())); }
|
MesProBatchScheduleReqVO request() { var r = new MesProBatchScheduleReqVO(); r.setWorkOrderIds(List.of(1L));
|
r.setStartTime(LocalDate.now(ZoneId.of("Asia/Shanghai")).plusDays(1).atTime(9,0)); return r; }
|
MesProBatchScheduleReqVO confirmable() { var r = request(); var p = service.preview(r); assertTrue(p.isCanExecute(), p.getOrders().toString());
|
r.setPreviewHash(p.getPreviewHash()); r.setPreviewTime(p.getPreviewTime()); r.setAllowLate(true); return r; }
|
}
|
}
|
