package com.ruoyi.order.controller;
|
|
import com.ruoyi.account.api.feignClient.AppUserClient;
|
import com.ruoyi.account.api.feignClient.AppUserTagClient;
|
import com.ruoyi.account.api.model.TAppUserTag;
|
import com.ruoyi.account.api.model.TAppUserCar;
|
import com.ruoyi.chargingPile.api.model.Site;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.order.api.query.ChargingOrderQuery;
|
import com.ruoyi.order.api.vo.TCharingOrderVO;
|
import com.ruoyi.order.dto.SixChargingDto;
|
import com.ruoyi.order.dto.EnterpriseChargingDetailVO;
|
import com.ruoyi.order.dto.FranchiseeDayStat;
|
import com.ruoyi.order.dto.FranchiseeUserAgg;
|
import com.ruoyi.order.export.EnterpriseChargingDetailExport;
|
import com.ruoyi.order.service.TChargingOrderService;
|
import com.ruoyi.other.api.domain.TUserTag;
|
import com.ruoyi.other.api.feignClient.UserTagClient;
|
import org.junit.jupiter.api.Test;
|
import org.springframework.test.util.ReflectionTestUtils;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.math.BigDecimal;
|
import java.util.Arrays;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.mockito.ArgumentMatchers.same;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.verifyNoInteractions;
|
import static org.mockito.Mockito.when;
|
|
class TChargingOrderControllerTest {
|
|
@Test
|
void franchiseeIncomeWanUsesManagementOrderSummaryIncome() {
|
FranchiseeDayStat discountedOrder = new FranchiseeDayStat();
|
discountedOrder.setPaymentAmount(new BigDecimal("90"));
|
discountedOrder.setChargingIncome(new BigDecimal("104"));
|
FranchiseeDayStat emptyIncomeOrder = new FranchiseeDayStat();
|
|
assertEquals(new BigDecimal("0.0104"),
|
TChargingOrderController.franchiseeIncomeWan(Arrays.asList(discountedOrder, emptyIncomeOrder)));
|
}
|
|
@Test
|
void appUserIdsBySiteIdsDelegatesToOrderService() {
|
TChargingOrderService chargingOrderService = mock(TChargingOrderService.class);
|
TChargingOrderController controller = new TChargingOrderController();
|
ReflectionTestUtils.setField(controller, "chargingOrderService", chargingOrderService);
|
List<Integer> siteIds = Arrays.asList(11, 12);
|
List<Long> userIds = Arrays.asList(101L, 102L);
|
when(chargingOrderService.getAppUserIdsBySiteIds(siteIds)).thenReturn(userIds);
|
|
com.ruoyi.common.core.domain.R<List<Long>> result = controller.getAppUserIdsBySiteIds(siteIds);
|
|
assertEquals(userIds, result.getData());
|
verify(chargingOrderService).getAppUserIdsBySiteIds(siteIds);
|
}
|
|
@Test
|
void enterpriseChargingDetailExportContainsVisibleDetailColumns() {
|
EnterpriseChargingDetailVO detail = new EnterpriseChargingDetailVO();
|
detail.setLicensePlate("川JD20960");
|
detail.setPartnerName("测试合作商");
|
detail.setOrderSource(0);
|
detail.setCreateTime(LocalDateTime.of(2026, 7, 29, 10, 20, 30));
|
detail.setChargingCapacity(new BigDecimal("40.693"));
|
detail.setElectrovalence(new BigDecimal("43.0857"));
|
detail.setServiceCharge(new BigDecimal("16.2772"));
|
detail.setEndMode(0);
|
detail.setPeriodCount(1);
|
|
EnterpriseChargingDetailExport export = ReflectionTestUtils.invokeMethod(
|
new TChargingOrderController(), "buildEnterpriseChargingDetailExport", detail);
|
|
assertEquals("川JD20960", export.getLicensePlate());
|
assertEquals("测试合作商", export.getPartnerName());
|
assertEquals("自有平台", export.getOrderSource());
|
assertEquals("2026-07-29 10:20:30", export.getCreateTime());
|
assertEquals(new BigDecimal("40.693"), export.getChargingCapacity());
|
assertEquals(new BigDecimal("43.0857"), export.getElectrovalence());
|
assertEquals(new BigDecimal("16.2772"), export.getServiceCharge());
|
assertEquals("异常终止", export.getEndMode());
|
assertEquals(1, export.getPeriodCount());
|
}
|
|
@Test
|
void latestAdjacentMonthDataMovesTheSixMonthWindowForward() {
|
SixChargingDto june = new SixChargingDto();
|
june.setMonth("06");
|
SixChargingDto july = new SixChargingDto();
|
july.setMonth("07");
|
|
LocalDate endMonth = TChargingOrderController.resolveStatisticsEndMonth(
|
LocalDate.of(2026, 6, 30), Arrays.asList(june, july));
|
List<SixChargingDto> months = TChargingOrderController.generateLastSixMonths(endMonth);
|
|
assertEquals(LocalDate.of(2026, 7, 30), endMonth);
|
assertEquals(Arrays.asList("02", "03", "04", "05", "06", "07"),
|
months.stream().map(SixChargingDto::getMonth).collect(java.util.stream.Collectors.toList()));
|
}
|
|
@Test
|
void blankPhoneDoesNotExpandQueryToAllUserIds() {
|
TChargingOrderService chargingOrderService = mock(TChargingOrderService.class);
|
AppUserClient appUserClient = mock(AppUserClient.class);
|
TChargingOrderController controller = new TChargingOrderController();
|
ReflectionTestUtils.setField(controller, "chargingOrderService", chargingOrderService);
|
ReflectionTestUtils.setField(controller, "appUserClient", appUserClient);
|
|
ChargingOrderQuery query = new ChargingOrderQuery();
|
query.setPhone("");
|
when(chargingOrderService.chargingOrder(same(query))).thenReturn(new TCharingOrderVO());
|
|
controller.chargingOrder(query);
|
|
assertNull(query.getUserIds());
|
verify(chargingOrderService).chargingOrder(same(query));
|
verifyNoInteractions(appUserClient);
|
}
|
|
@Test
|
void partnerFilterIncludesPrimaryAndVenueSitesRegardlessOfPartnerType() {
|
Site primarySite = new Site();
|
primarySite.setId(11);
|
primarySite.setPartnerId(9);
|
Site venueSite = new Site();
|
venueSite.setId(12);
|
venueSite.setPartnerId(3);
|
venueSite.setVenuePartnerId(9);
|
Site unrelatedSite = new Site();
|
unrelatedSite.setId(13);
|
unrelatedSite.setPartnerId(4);
|
|
List<Integer> result = TChargingOrderController.filterPlatformRevenueSiteIdsByPartner(
|
Arrays.asList(11, 12, 13), Arrays.asList(primarySite, venueSite, unrelatedSite), 9);
|
|
assertEquals(Arrays.asList(11, 12), result);
|
}
|
|
@Test
|
void partnerFilterReturnsImpossibleSiteWhenPartnerHasNoAuthorizedSites() {
|
Site unrelatedSite = new Site();
|
unrelatedSite.setId(13);
|
unrelatedSite.setPartnerId(4);
|
|
List<Integer> result = TChargingOrderController.filterPlatformRevenueSiteIdsByPartner(
|
Arrays.asList(13), Arrays.asList(unrelatedSite), 9);
|
|
assertEquals(Arrays.asList(-1), result);
|
}
|
|
@Test
|
void franchiseeUserTagsUsesPersistedUserTagsInsteadOfChargeFrequency() {
|
TChargingOrderController controller = new TChargingOrderController();
|
AppUserTagClient appUserTagClient = mock(AppUserTagClient.class);
|
UserTagClient userTagClient = mock(UserTagClient.class);
|
ReflectionTestUtils.setField(controller, "appUserTagClient", appUserTagClient);
|
ReflectionTestUtils.setField(controller, "userTagClient", userTagClient);
|
|
TUserTag oldUser = new TUserTag();
|
oldUser.setId(1);
|
oldUser.setName("老用户");
|
TUserTag activeUser = new TUserTag();
|
activeUser.setId(2);
|
activeUser.setName("活跃用户");
|
when(userTagClient.getAllUserTag()).thenReturn(R.ok(Arrays.asList(oldUser, activeUser)));
|
|
TAppUserTag oldUserTag = new TAppUserTag();
|
oldUserTag.setAppUserId(101L);
|
oldUserTag.setUserTagId(1);
|
TAppUserTag duplicateOldUserTag = new TAppUserTag();
|
duplicateOldUserTag.setAppUserId(101L);
|
duplicateOldUserTag.setUserTagId(1);
|
TAppUserTag activeUserTag = new TAppUserTag();
|
activeUserTag.setAppUserId(101L);
|
activeUserTag.setUserTagId(2);
|
when(appUserTagClient.listByUserIds(org.mockito.ArgumentMatchers.anyList()))
|
.thenReturn(R.ok(Arrays.asList(oldUserTag, duplicateOldUserTag, activeUserTag)));
|
|
FranchiseeUserAgg firstAgg = new FranchiseeUserAgg();
|
firstAgg.setAppUserId(101L);
|
FranchiseeUserAgg repeatAgg = new FranchiseeUserAgg();
|
repeatAgg.setAppUserId(101L);
|
FranchiseeUserAgg untaggedAgg = new FranchiseeUserAgg();
|
untaggedAgg.setAppUserId(102L);
|
|
@SuppressWarnings("unchecked")
|
List<java.util.Map<String, Object>> result = ReflectionTestUtils.invokeMethod(controller,
|
"franchiseeUserTags", Arrays.asList(firstAgg, repeatAgg, untaggedAgg));
|
|
assertEquals(2, result.size());
|
assertEquals("老用户", result.get(0).get("name"));
|
assertEquals(1L, result.get(0).get("value"));
|
assertEquals("活跃用户", result.get(1).get("name"));
|
assertEquals(1L, result.get(1).get("value"));
|
verify(appUserTagClient).listByUserIds(org.mockito.ArgumentMatchers.anyList());
|
}
|
|
@Test
|
void franchiseeVehicleClassCountsOrdersInsteadOfDistinctVehicles() {
|
TAppUserCar privateCar = new TAppUserCar();
|
privateCar.setId(1L);
|
privateCar.setVehicleUse("私家车");
|
TAppUserCar companyCar = new TAppUserCar();
|
companyCar.setId(2L);
|
companyCar.setVehicleUse("企业车");
|
List<FranchiseeUserAgg> aggs = new java.util.ArrayList<>();
|
for (int i = 0; i < 10; i++) {
|
FranchiseeUserAgg agg = new FranchiseeUserAgg();
|
agg.setAppUserCarId(1L);
|
agg.setOrderCount(1L);
|
aggs.add(agg);
|
}
|
for (int i = 0; i < 3; i++) {
|
FranchiseeUserAgg agg = new FranchiseeUserAgg();
|
agg.setAppUserCarId(2L);
|
agg.setOrderCount(1L);
|
aggs.add(agg);
|
}
|
|
@SuppressWarnings("unchecked")
|
List<java.util.Map<String, Object>> result = ReflectionTestUtils.invokeMethod(
|
new TChargingOrderController(), "franchiseeOrderCarGroup", aggs,
|
Arrays.asList(privateCar, companyCar),
|
(java.util.function.Function<TAppUserCar, String>) TAppUserCar::getVehicleUse,
|
"未知用途", 5);
|
|
assertEquals("私家车", result.get(0).get("name"));
|
assertEquals(10L, result.get(0).get("value"));
|
assertEquals("企业车", result.get(1).get("name"));
|
assertEquals(3L, result.get(1).get("value"));
|
}
|
|
@Test
|
void franchiseeManagementOrderStatsUsesSameServiceAndDateRangeAsManagementStatistics() {
|
TChargingOrderController controller = new TChargingOrderController();
|
TChargingOrderService chargingOrderService = mock(TChargingOrderService.class);
|
ReflectionTestUtils.setField(controller, "chargingOrderService", chargingOrderService);
|
List<Integer> siteIds = Arrays.asList(11, 12);
|
LocalDate start = LocalDate.of(2026, 8, 1);
|
LocalDate end = LocalDate.of(2026, 8, 31);
|
List<Map<String, Object>> managementStats = Arrays.asList(managementStat("2026-08", "123.45", 7));
|
when(chargingOrderService.getByDate(start, end, siteIds)).thenReturn(managementStats);
|
|
@SuppressWarnings("unchecked")
|
List<Map<String, Object>> result = ReflectionTestUtils.invokeMethod(controller,
|
"franchiseeManagementOrderStats", siteIds,
|
new LocalDateTime[]{start.atStartOfDay(), end.plusDays(1).atStartOfDay()});
|
|
assertEquals(managementStats, result);
|
verify(chargingOrderService).getByDate(start, end, siteIds);
|
}
|
|
@Test
|
void franchiseeManagementOrderTrendKeepsManagementValuesWithoutRecalculating() {
|
TChargingOrderController controller = new TChargingOrderController();
|
List<Map<String, Object>> stats = Arrays.asList(
|
managementStat("2026-08-01", "12.34", 2),
|
managementStat("2026-08-02", "56.78", 3));
|
|
@SuppressWarnings("unchecked")
|
Map<String, Object> chart = ReflectionTestUtils.invokeMethod(controller,
|
"franchiseeManagementOrderTrend", stats);
|
@SuppressWarnings("unchecked")
|
List<Map<String, Object>> series = (List<Map<String, Object>>) chart.get("series");
|
|
assertEquals(Arrays.asList("2026-08-01", "2026-08-02"), chart.get("categories"));
|
assertEquals(Arrays.asList(new BigDecimal("12.34"), new BigDecimal("56.78")), series.get(0).get("data"));
|
assertEquals(Arrays.asList(new BigDecimal("2"), new BigDecimal("3")), series.get(1).get("data"));
|
}
|
|
private Map<String, Object> managementStat(String time, String paymoney, int orderCount) {
|
Map<String, Object> stat = new LinkedHashMap<>();
|
stat.put("time", time);
|
stat.put("paymoney", new BigDecimal(paymoney));
|
stat.put("orderCount", orderCount);
|
return stat;
|
}
|
}
|
