package com.ruoyi.account.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.ruoyi.account.api.dto.CompanyAllocateRecordQueryDTO;
|
import com.ruoyi.account.api.model.TAppUserWhitelist;
|
import com.ruoyi.account.api.model.TChargingCard;
|
import com.ruoyi.account.api.model.TCompanyAllocateRecord;
|
import com.ruoyi.account.api.model.TVinManagement;
|
import com.ruoyi.account.api.vo.CompanyAllocateSummaryVO;
|
import com.ruoyi.account.mapper.TAppUserWhitelistMapper;
|
import com.ruoyi.account.mapper.TChargingCardMapper;
|
import com.ruoyi.account.mapper.TCompanyAllocateRecordMapper;
|
import com.ruoyi.account.mapper.TVinManagementMapper;
|
import com.ruoyi.common.core.context.SecurityContextHolder;
|
import com.ruoyi.common.core.exception.ServiceException;
|
import org.junit.jupiter.api.AfterEach;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.api.extension.ExtendWith;
|
import org.mockito.ArgumentCaptor;
|
import org.mockito.Mock;
|
import org.mockito.junit.jupiter.MockitoExtension;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.test.util.ReflectionTestUtils;
|
|
import java.math.BigDecimal;
|
import java.util.Arrays;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.concurrent.TimeUnit;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
import static org.junit.jupiter.api.Assertions.assertSame;
|
import static org.junit.jupiter.api.Assertions.assertThrows;
|
import static org.junit.jupiter.api.Assertions.assertTrue;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.anyString;
|
import static org.mockito.ArgumentMatchers.eq;
|
import static org.mockito.Mockito.lenient;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.spy;
|
import static org.mockito.Mockito.times;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
@ExtendWith(MockitoExtension.class)
|
class TCompanyAllocateRecordServiceImplTest {
|
|
@Mock private TCompanyAllocateRecordMapper mapper;
|
@Mock private TVinManagementMapper vinMapper;
|
@Mock private TChargingCardMapper cardMapper;
|
@Mock private TAppUserWhitelistMapper whitelistMapper;
|
@Mock private RedissonClient redissonClient;
|
@Mock private RLock lock;
|
private TCompanyAllocateRecordServiceImpl service;
|
|
@BeforeEach
|
void setUp() {
|
service = spy(new TCompanyAllocateRecordServiceImpl());
|
ReflectionTestUtils.setField(service, "baseMapper", mapper);
|
ReflectionTestUtils.setField(service, "vinManagementMapper", vinMapper);
|
ReflectionTestUtils.setField(service, "chargingCardMapper", cardMapper);
|
ReflectionTestUtils.setField(service, "appUserWhitelistMapper", whitelistMapper);
|
ReflectionTestUtils.setField(service, "redissonClient", redissonClient);
|
lenient().when(mapper.insert(any(TCompanyAllocateRecord.class))).thenReturn(1);
|
lenient().when(redissonClient.getLock(anyString())).thenReturn(lock);
|
SecurityContextHolder.setUserId("123");
|
SecurityContextHolder.setUserName("admin");
|
}
|
|
@AfterEach
|
void tearDown() {
|
SecurityContextHolder.remove();
|
}
|
|
@Test
|
void recordAllocateWritesBeforeAfterAndOperator() {
|
boolean saved = service.recordAllocate(TCompanyAllocateRecord.USER_TYPE_VIN, "LVIN0001", null, 9,
|
TCompanyAllocateRecord.SOURCE_ALLOCATE, new BigDecimal("10.5"), new BigDecimal("20.25"), "额度分配");
|
|
assertTrue(saved);
|
TCompanyAllocateRecord record = captureInserted();
|
assertEquals(9, record.getCompanyId());
|
assertEquals(TCompanyAllocateRecord.USER_TYPE_VIN, record.getUserType());
|
assertEquals("LVIN0001", record.getUserInfo());
|
assertEquals(TCompanyAllocateRecord.SOURCE_ALLOCATE, record.getChangeSource());
|
assertEquals(new BigDecimal("10.50"), record.getBeforeBalance());
|
assertEquals(new BigDecimal("20.25"), record.getAmount());
|
assertEquals(new BigDecimal("30.75"), record.getAfterBalance());
|
assertEquals(123L, record.getOperatorId());
|
assertEquals("admin", record.getOperatorName());
|
assertNotNull(record.getOperateTime());
|
assertEquals(record.getOperateTime(), record.getCreateTime());
|
}
|
|
@Test
|
void recordAllocateSupportsNegativeAmountForRecycle() {
|
service.recordAllocate(TCompanyAllocateRecord.USER_TYPE_WHITELIST, "13800000000", "张三", 5,
|
TCompanyAllocateRecord.SOURCE_EDIT, new BigDecimal("100"), new BigDecimal("-40"), "编辑白名单调减初始分配额度");
|
|
TCompanyAllocateRecord record = captureInserted();
|
assertEquals("13800000000", record.getUserInfo());
|
assertEquals("张三", record.getUserName());
|
assertEquals(new BigDecimal("60.00"), record.getAfterBalance());
|
assertEquals(new BigDecimal("-40.00"), record.getAmount());
|
}
|
|
@Test
|
void recordAllocateSkipsWhenCompanyMissingOrAmountZero() {
|
assertFalse(service.recordAllocate(TCompanyAllocateRecord.USER_TYPE_CARD, "CARD-1", null, null,
|
TCompanyAllocateRecord.SOURCE_CREATE, BigDecimal.ZERO, new BigDecimal("10"), null));
|
assertFalse(service.recordAllocate(TCompanyAllocateRecord.USER_TYPE_CARD, "CARD-1", null, 8,
|
TCompanyAllocateRecord.SOURCE_CREATE, BigDecimal.ZERO, BigDecimal.ZERO, null));
|
|
verify(mapper, never()).insert(any(TCompanyAllocateRecord.class));
|
}
|
|
@Test
|
void recordAllocateTruncatesOverlongText() {
|
String overlong = repeat('V', 80);
|
service.recordAllocate(TCompanyAllocateRecord.USER_TYPE_VIN, overlong, overlong, 3,
|
TCompanyAllocateRecord.SOURCE_CREATE, BigDecimal.ZERO, new BigDecimal("1"), repeat('R', 300));
|
|
TCompanyAllocateRecord record = captureInserted();
|
assertEquals(64, record.getUserInfo().length());
|
assertEquals(64, record.getUserName().length());
|
assertEquals(255, record.getRemark().length());
|
}
|
|
@Test
|
void recordAllocateWithoutLoginKeepsOperatorEmpty() {
|
SecurityContextHolder.remove();
|
|
assertTrue(service.recordAllocate(TCompanyAllocateRecord.USER_TYPE_VIN, "LVIN0002", null, 3,
|
TCompanyAllocateRecord.SOURCE_CREATE, BigDecimal.ZERO, new BigDecimal("5"), "新增VIN码初始分配额度"));
|
|
TCompanyAllocateRecord record = captureInserted();
|
assertNull(record.getOperatorId());
|
assertNull(record.getOperatorName());
|
}
|
|
@Test
|
void selectRecordPagePassesQueryAndPaging() {
|
Page<TCompanyAllocateRecord> expected = new Page<>(2, 10);
|
when(mapper.selectRecordPage(any(Page.class), any())).thenReturn(expected);
|
CompanyAllocateRecordQueryDTO query = new CompanyAllocateRecordQueryDTO();
|
query.setCompanyId(7);
|
query.setPageCurr(2);
|
query.setPageSize(10);
|
|
IPage<TCompanyAllocateRecord> result = service.selectRecordPage(query);
|
|
ArgumentCaptor<Page<TCompanyAllocateRecord>> pageCaptor = ArgumentCaptor.forClass(Page.class);
|
verify(mapper).selectRecordPage(pageCaptor.capture(), any());
|
assertEquals(2, pageCaptor.getValue().getCurrent());
|
assertEquals(10, pageCaptor.getValue().getSize());
|
assertSame(expected, result);
|
}
|
|
@Test
|
void selectRecordPageFallsBackToSafeDefaults() {
|
when(mapper.selectRecordPage(any(Page.class), any())).thenReturn(new Page<>());
|
CompanyAllocateRecordQueryDTO query = new CompanyAllocateRecordQueryDTO();
|
query.setPageCurr(0);
|
query.setPageSize(0);
|
|
service.selectRecordPage(null);
|
ArgumentCaptor<Page<TCompanyAllocateRecord>> firstPage = ArgumentCaptor.forClass(Page.class);
|
verify(mapper).selectRecordPage(firstPage.capture(), any());
|
assertEquals(1, firstPage.getValue().getCurrent());
|
assertEquals(50, firstPage.getValue().getSize());
|
|
service.selectRecordPage(query);
|
ArgumentCaptor<Page<TCompanyAllocateRecord>> secondPage = ArgumentCaptor.forClass(Page.class);
|
verify(mapper, times(2)).selectRecordPage(secondPage.capture(), any());
|
assertEquals(1, secondPage.getAllValues().get(1).getCurrent());
|
assertEquals(10, secondPage.getAllValues().get(1).getSize());
|
}
|
|
private TCompanyAllocateRecord captureInserted() {
|
ArgumentCaptor<TCompanyAllocateRecord> captor = ArgumentCaptor.forClass(TCompanyAllocateRecord.class);
|
verify(mapper).insert(captor.capture());
|
return captor.getValue();
|
}
|
|
// ============ 账户模式切换回收相关 ============
|
|
@Test
|
void sumAllocatedBalanceAggregatesThreeTypes() {
|
TVinManagement vin = new TVinManagement();
|
vin.setId(1L);
|
vin.setBalance(new BigDecimal("10.50"));
|
vin.setLockedAmount(new BigDecimal("2.00"));
|
TVinManagement vin2 = new TVinManagement();
|
vin2.setId(2L);
|
vin2.setBalance(new BigDecimal("5.25"));
|
vin2.setLockedAmount(BigDecimal.ZERO);
|
when(vinMapper.selectList(any())).thenReturn(Arrays.asList(vin, vin2));
|
|
TChargingCard card = new TChargingCard();
|
card.setId(3L);
|
card.setBalance(new BigDecimal("8.00"));
|
card.setLockedAmount(new BigDecimal("1.50"));
|
when(cardMapper.selectList(any())).thenReturn(Collections.singletonList(card));
|
|
TAppUserWhitelist whitelist = new TAppUserWhitelist();
|
whitelist.setId(4L);
|
whitelist.setBalance(new BigDecimal("6.00"));
|
whitelist.setLockedAmount(BigDecimal.ZERO);
|
when(whitelistMapper.selectList(any())).thenReturn(Collections.singletonList(whitelist));
|
|
CompanyAllocateSummaryVO summary = service.sumAllocatedBalance(9);
|
|
assertEquals(9, summary.getCompanyId());
|
assertEquals(new BigDecimal("29.75"), summary.getTotalBalance());
|
assertEquals(new BigDecimal("3.50"), summary.getTotalLocked());
|
assertEquals(4, summary.getBalanceUserCount());
|
}
|
|
@Test
|
void recycleAllocatedBalanceClearsAndWritesBothSides() throws InterruptedException {
|
when(lock.tryLock(5L, 30L, TimeUnit.SECONDS)).thenReturn(true);
|
when(lock.isHeldByCurrentThread()).thenReturn(true);
|
|
TVinManagement vin = new TVinManagement();
|
vin.setId(1L);
|
vin.setBalance(new BigDecimal("10.00"));
|
vin.setVin("LVIN0001");
|
vin.setPlateNumber("粤A12345");
|
when(vinMapper.selectList(any())).thenReturn(Collections.singletonList(vin));
|
when(vinMapper.clearBalance(eq(1L), eq(123L))).thenReturn(1);
|
|
TChargingCard card = new TChargingCard();
|
card.setId(2L);
|
card.setBalance(new BigDecimal("20.00"));
|
card.setCardNo("CARD0001");
|
when(cardMapper.selectList(any())).thenReturn(Collections.singletonList(card));
|
when(cardMapper.clearBalance(eq(2L), eq(123L))).thenReturn(1);
|
|
TAppUserWhitelist whitelist = new TAppUserWhitelist();
|
whitelist.setId(3L);
|
whitelist.setBalance(new BigDecimal("30.00"));
|
whitelist.setPhone("13800000000");
|
whitelist.setName("张三");
|
when(whitelistMapper.selectList(any())).thenReturn(Collections.singletonList(whitelist));
|
when(whitelistMapper.clearBalance(eq(3L), eq("admin"))).thenReturn(1);
|
|
BigDecimal recycled = service.recycleAllocatedBalance(9, "admin", "测试公司", new BigDecimal("100.00"));
|
|
assertEquals(new BigDecimal("60.00"), recycled);
|
verify(vinMapper).clearBalance(1L, 123L);
|
verify(cardMapper).clearBalance(2L, 123L);
|
verify(whitelistMapper).clearBalance(3L, "admin");
|
// 3 条用户负流水 + 1 条企业账户正流水
|
verify(mapper, times(4)).insert(any(TCompanyAllocateRecord.class));
|
ArgumentCaptor<TCompanyAllocateRecord> captor = ArgumentCaptor.forClass(TCompanyAllocateRecord.class);
|
verify(mapper, times(4)).insert(captor.capture());
|
List<TCompanyAllocateRecord> records = captor.getAllValues();
|
TCompanyAllocateRecord companyRecord = records.get(records.size() - 1);
|
assertEquals(TCompanyAllocateRecord.USER_TYPE_COMPANY, companyRecord.getUserType());
|
assertEquals("测试公司", companyRecord.getUserInfo());
|
assertEquals(TCompanyAllocateRecord.SOURCE_MODE_SWITCH, companyRecord.getChangeSource());
|
assertEquals(new BigDecimal("100.00"), companyRecord.getBeforeBalance());
|
assertEquals(new BigDecimal("60.00"), companyRecord.getAmount());
|
assertEquals(new BigDecimal("160.00"), companyRecord.getAfterBalance());
|
for (int i = 0; i < 3; i++) {
|
assertEquals(TCompanyAllocateRecord.SOURCE_MODE_SWITCH, records.get(i).getChangeSource());
|
assertTrue(records.get(i).getAmount().signum() < 0);
|
}
|
}
|
|
@Test
|
void recycleAllocatedBalanceIsIdempotentWhenNoBalanceLeft() throws InterruptedException {
|
when(lock.tryLock(5L, 30L, TimeUnit.SECONDS)).thenReturn(true);
|
when(lock.isHeldByCurrentThread()).thenReturn(true);
|
when(vinMapper.selectList(any())).thenReturn(Collections.emptyList());
|
when(cardMapper.selectList(any())).thenReturn(Collections.emptyList());
|
when(whitelistMapper.selectList(any())).thenReturn(Collections.emptyList());
|
|
BigDecimal recycled = service.recycleAllocatedBalance(9, "admin", "测试公司", new BigDecimal("100.00"));
|
|
assertEquals(new BigDecimal("0.00"), recycled);
|
verify(mapper, never()).insert(any(TCompanyAllocateRecord.class));
|
}
|
|
@Test
|
void recycleAllocatedBalanceThrowsWhenLockBusy() throws InterruptedException {
|
when(lock.tryLock(5L, 30L, TimeUnit.SECONDS)).thenReturn(false);
|
|
assertThrows(ServiceException.class,
|
() -> service.recycleAllocatedBalance(9, "admin", "测试公司", new BigDecimal("100.00")));
|
verify(vinMapper, never()).selectList(any());
|
}
|
|
@Test
|
void recycleAllocatedBalanceRejectsMissingCompany() {
|
assertThrows(ServiceException.class, () -> service.recycleAllocatedBalance(null, "admin", null, null));
|
verify(mapper, never()).insert(any(TCompanyAllocateRecord.class));
|
}
|
|
private String repeat(char value, int count) {
|
StringBuilder builder = new StringBuilder(count);
|
for (int i = 0; i < count; i++) {
|
builder.append(value);
|
}
|
return builder.toString();
|
}
|
}
|
