package com.tourguide.modules.order.service;
|
|
import com.tourguide.modules.operation.entity.OperationScenicSpot;
|
import com.tourguide.modules.operation.entity.ScenicPricing;
|
import com.tourguide.modules.operation.mapper.OperationScenicSpotMapper;
|
import com.tourguide.modules.operation.mapper.ScenicPricingMapper;
|
import com.tourguide.modules.order.domain.OrderStatus;
|
import com.tourguide.modules.order.entity.TourOrder;
|
import com.tourguide.modules.order.mapper.TourOrderMapper;
|
import com.tourguide.modules.system.service.GuideNotificationService;
|
import com.tourguide.modules.user.entity.GuideReceivingSession;
|
import com.tourguide.modules.user.entity.GuideUser;
|
import com.tourguide.modules.user.mapper.GuideRealtimeStatusMapper;
|
import com.tourguide.modules.user.mapper.GuideReceivingSessionMapper;
|
import com.tourguide.modules.user.mapper.GuideUserMapper;
|
import org.mockito.ArgumentCaptor;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.Collections;
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.eq;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
class GuideOrderMatchingServiceTest {
|
private TourOrderMapper orderMapper;
|
private GuideReceivingSessionMapper sessionMapper;
|
private GuideUserMapper guideUserMapper;
|
private GuideRealtimeStatusMapper realtimeStatusMapper;
|
private OperationScenicSpotMapper scenicMapper;
|
private ScenicPricingMapper pricingMapper;
|
private GuideOrderEarningSnapshotService earningSnapshotService;
|
private GuideNotificationService notificationService;
|
private GuideOrderMatchingService service;
|
|
@BeforeEach
|
void setUp() {
|
orderMapper = mock(TourOrderMapper.class);
|
sessionMapper = mock(GuideReceivingSessionMapper.class);
|
guideUserMapper = mock(GuideUserMapper.class);
|
realtimeStatusMapper = mock(GuideRealtimeStatusMapper.class);
|
scenicMapper = mock(OperationScenicSpotMapper.class);
|
pricingMapper = mock(ScenicPricingMapper.class);
|
earningSnapshotService = mock(GuideOrderEarningSnapshotService.class);
|
notificationService = mock(GuideNotificationService.class);
|
service = new GuideOrderMatchingService(orderMapper, sessionMapper, guideUserMapper,
|
realtimeStatusMapper, scenicMapper, pricingMapper, earningSnapshotService, notificationService);
|
}
|
|
@Test
|
void shouldAssignSecondGroupOrderToInServiceSessionWhileCapacityRemains() {
|
TourOrder firstOrder = groupOrder(1L);
|
TourOrder secondOrder = groupOrder(2L);
|
GuideReceivingSession session = receivingSession("RECEIVING", 0);
|
ScenicPricing pricing = groupPricing();
|
OperationScenicSpot scenic = scenicSpot();
|
GuideUser guide = guide();
|
|
when(orderMapper.selectForUpdate(1L)).thenReturn(firstOrder);
|
when(orderMapper.selectForUpdate(2L)).thenReturn(secondOrder);
|
when(sessionMapper.selectMatchCandidates(11L, 12L, "GROUP", "GROUP_PREMIUM"))
|
.thenReturn(Collections.singletonList(session));
|
when(pricingMapper.selectById(30L)).thenReturn(pricing);
|
when(scenicMapper.selectById(11L)).thenReturn(scenic);
|
when(guideUserMapper.selectById(7L)).thenReturn(guide);
|
when(sessionMapper.reserveGroupCapacity(eq(41L), eq(1), eq(2), any(LocalDateTime.class),
|
any(LocalDateTime.class), any(LocalDateTime.class))).thenReturn(1);
|
|
assertThat(service.match(1L)).isTrue();
|
assertThat(firstOrder.getStatus()).isEqualTo(OrderStatus.PENDING_MEETING.getCode());
|
|
session.setStatus("IN_SERVICE");
|
session.setCurrentPeopleCount(1);
|
|
assertThat(service.match(2L)).isTrue();
|
assertThat(secondOrder.getGuideId()).isEqualTo(7L);
|
assertThat(secondOrder.getReceivingSessionId()).isEqualTo(41L);
|
assertThat(secondOrder.getStatus()).isEqualTo(OrderStatus.IN_SERVICE.getCode());
|
assertThat(secondOrder.getServiceStartedAt()).isNotNull();
|
verify(notificationService).notifyOrderAssigned(secondOrder);
|
}
|
|
@Test
|
void shouldApplyScenicLeadTimeToPrivateOrderSession() {
|
TourOrder order = privateOrder(3L);
|
GuideReceivingSession session = receivingSession("RECEIVING", 0);
|
session.setReceivingMode("PRIVATE");
|
ScenicPricing pricing = privatePricing();
|
OperationScenicSpot scenic = scenicSpot();
|
GuideUser guide = guide();
|
|
when(orderMapper.selectForUpdate(3L)).thenReturn(order);
|
when(sessionMapper.selectMatchCandidates(11L, 12L, "PRIVATE", "PRIVATE_QUICK"))
|
.thenReturn(Collections.singletonList(session));
|
when(pricingMapper.selectById(30L)).thenReturn(pricing);
|
when(scenicMapper.selectById(11L)).thenReturn(scenic);
|
when(guideUserMapper.selectById(7L)).thenReturn(guide);
|
when(sessionMapper.assignPrivate(eq(41L), eq(1), any(LocalDateTime.class), any(LocalDateTime.class)))
|
.thenReturn(1);
|
|
assertThat(service.match(3L)).isTrue();
|
|
ArgumentCaptor<LocalDateTime> now = ArgumentCaptor.forClass(LocalDateTime.class);
|
ArgumentCaptor<LocalDateTime> serviceStartAt = ArgumentCaptor.forClass(LocalDateTime.class);
|
verify(sessionMapper).assignPrivate(eq(41L), eq(1), now.capture(), serviceStartAt.capture());
|
assertThat(serviceStartAt.getValue()).isEqualTo(now.getValue().plusMinutes(10));
|
assertThat(order.getStatus()).isEqualTo(OrderStatus.PENDING_MEETING.getCode());
|
}
|
|
private TourOrder groupOrder(Long id) {
|
TourOrder order = new TourOrder();
|
order.setId(id);
|
order.setScenicSpotId(11L);
|
order.setMeetingPointId(12L);
|
order.setServicePackageId(30L);
|
order.setOrderType("GROUP_PREMIUM");
|
order.setPeopleCount(1);
|
order.setStatus(OrderStatus.PENDING_ACCEPT.getCode());
|
return order;
|
}
|
|
private TourOrder privateOrder(Long id) {
|
TourOrder order = groupOrder(id);
|
order.setOrderType("PRIVATE_QUICK");
|
return order;
|
}
|
|
private GuideReceivingSession receivingSession(String status, int peopleCount) {
|
GuideReceivingSession session = new GuideReceivingSession();
|
session.setId(41L);
|
session.setGuideId(7L);
|
session.setScenicSpotId(11L);
|
session.setMeetingPointId(12L);
|
session.setReceivingMode("GROUP");
|
session.setServiceTypes("GROUP_PREMIUM");
|
session.setStatus(status);
|
session.setCurrentPeopleCount(peopleCount);
|
return session;
|
}
|
|
private ScenicPricing groupPricing() {
|
ScenicPricing pricing = new ScenicPricing();
|
pricing.setId(30L);
|
pricing.setScenicSpotId(11L);
|
pricing.setServiceType("GROUP_PREMIUM");
|
pricing.setMaxParticipants(2);
|
pricing.setDiscountPrice(new BigDecimal("86.00"));
|
return pricing;
|
}
|
|
private ScenicPricing privatePricing() {
|
ScenicPricing pricing = new ScenicPricing();
|
pricing.setId(30L);
|
pricing.setScenicSpotId(11L);
|
pricing.setServiceType("PRIVATE_QUICK");
|
pricing.setDiscountPrice(new BigDecimal("536.00"));
|
return pricing;
|
}
|
|
private OperationScenicSpot scenicSpot() {
|
OperationScenicSpot scenic = new OperationScenicSpot();
|
scenic.setId(11L);
|
scenic.setFirstOrderLeadMinutes(10);
|
scenic.setVisitorNoOrderMinutes(6);
|
return scenic;
|
}
|
|
private GuideUser guide() {
|
GuideUser guide = new GuideUser();
|
guide.setId(7L);
|
guide.setRealName("导游");
|
guide.setMobile("13800000000");
|
return guide;
|
}
|
}
|
