package com.ruoyi.account.service.impl;
|
|
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
|
import com.ruoyi.account.api.model.TAppUser;
|
import com.ruoyi.account.api.model.TAppUserWhitelist;
|
import com.ruoyi.account.api.vo.AppUserWhitelistImportResultVO;
|
import com.ruoyi.account.mapper.TAppUserWhitelistMapper;
|
import com.ruoyi.account.service.TAppUserService;
|
import com.ruoyi.account.service.TAppUserWhitelistSiteService;
|
import com.ruoyi.chargingPile.api.feignClient.PartnerClient;
|
import com.ruoyi.chargingPile.api.feignClient.SiteClient;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.common.security.service.TokenService;
|
import com.ruoyi.other.api.feignClient.GroupCompanyClient;
|
import com.ruoyi.system.api.feignClient.SysUserClient;
|
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
import org.junit.jupiter.api.extension.ExtendWith;
|
import org.mockito.Mock;
|
import org.mockito.junit.jupiter.MockitoExtension;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.mock.web.MockMultipartFile;
|
import org.springframework.test.util.ReflectionTestUtils;
|
import org.springframework.transaction.PlatformTransactionManager;
|
import org.springframework.transaction.TransactionStatus;
|
|
import java.io.ByteArrayOutputStream;
|
import java.util.Collections;
|
import java.util.concurrent.TimeUnit;
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.anyLong;
|
import static org.mockito.Mockito.doAnswer;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
@ExtendWith(MockitoExtension.class)
|
class TAppUserWhitelistServiceImplTest {
|
@Mock private TAppUserWhitelistMapper mapper;
|
@Mock private TAppUserWhitelistSiteService whitelistSiteService;
|
@Mock private TAppUserService appUserService;
|
@Mock private SiteClient siteClient;
|
@Mock private PartnerClient partnerClient;
|
@Mock private TokenService tokenService;
|
@Mock private SysUserClient sysUserClient;
|
@Mock private PlatformTransactionManager transactionManager;
|
@Mock private GroupCompanyClient groupCompanyClient;
|
@Mock private RedissonClient redissonClient;
|
|
private TAppUserWhitelistServiceImpl service;
|
|
@BeforeEach
|
void setUp() {
|
service = new TAppUserWhitelistServiceImpl();
|
ReflectionTestUtils.setField(service, "baseMapper", mapper);
|
ReflectionTestUtils.setField(service, "whitelistSiteService", whitelistSiteService);
|
ReflectionTestUtils.setField(service, "appUserService", appUserService);
|
ReflectionTestUtils.setField(service, "siteClient", siteClient);
|
ReflectionTestUtils.setField(service, "partnerClient", partnerClient);
|
ReflectionTestUtils.setField(service, "tokenService", tokenService);
|
ReflectionTestUtils.setField(service, "sysUserClient", sysUserClient);
|
ReflectionTestUtils.setField(service, "transactionManager", transactionManager);
|
ReflectionTestUtils.setField(service, "groupCompanyClient", groupCompanyClient);
|
ReflectionTestUtils.setField(service, "redissonClient", redissonClient);
|
RLock lock = mock(RLock.class);
|
when(redissonClient.getLock(any())).thenReturn(lock);
|
try {
|
when(lock.tryLock(anyLong(), anyLong(), any(TimeUnit.class))).thenReturn(true);
|
} catch (InterruptedException exception) {
|
throw new IllegalStateException(exception);
|
}
|
}
|
|
@Test
|
void importsValidRowsAndReturnsOnlyInvalidRows() throws Exception {
|
when(siteClient.getSiteAll()).thenReturn(R.ok(Collections.emptyList()));
|
when(mapper.selectValidByPhone(any())).thenReturn(null);
|
TransactionStatus transactionStatus = mock(TransactionStatus.class);
|
when(transactionManager.getTransaction(any())).thenReturn(transactionStatus);
|
LambdaQueryChainWrapper<TAppUser> appUserQuery = mock(LambdaQueryChainWrapper.class);
|
when(appUserService.lambdaQuery()).thenReturn(appUserQuery);
|
when(appUserQuery.eq(any(), any())).thenReturn(appUserQuery);
|
when(appUserQuery.last(any())).thenReturn(appUserQuery);
|
when(appUserQuery.one()).thenReturn(null);
|
AtomicLong ids = new AtomicLong(1L);
|
doAnswer(invocation -> {
|
TAppUserWhitelist whitelist = invocation.getArgument(0);
|
whitelist.setId(ids.getAndIncrement());
|
return 1;
|
}).when(mapper).insert(any(TAppUserWhitelist.class));
|
|
AppUserWhitelistImportResultVO result = service.importWhitelist(importFile());
|
|
assertEquals(3, result.getTotalCount());
|
assertEquals(2, result.getSuccessCount());
|
assertEquals(1, result.getErrorCount());
|
assertEquals("13540211237", result.getErrorMessage().get(0).getPhone());
|
verify(mapper, org.mockito.Mockito.times(2)).insert(any(TAppUserWhitelist.class));
|
}
|
|
private MockMultipartFile importFile() throws Exception {
|
try (XSSFWorkbook workbook = new XSSFWorkbook(); ByteArrayOutputStream output = new ByteArrayOutputStream()) {
|
org.apache.poi.ss.usermodel.Sheet sheet = workbook.createSheet("白名单用户");
|
org.apache.poi.ss.usermodel.Row header = sheet.createRow(0);
|
header.createCell(0).setCellValue("用户手机号");
|
header.createCell(1).setCellValue("享受权益");
|
header.createCell(2).setCellValue("白名单电站");
|
addRow(sheet, 1, "13540211236", "1", "all");
|
addRow(sheet, 2, "13540211238", "2", "all");
|
addRow(sheet, 3, "13540211237", "", "all");
|
workbook.write(output);
|
return new MockMultipartFile("file", "whitelist.xlsx",
|
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", output.toByteArray());
|
}
|
}
|
|
private void addRow(org.apache.poi.ss.usermodel.Sheet sheet, int index,
|
String phone, String benefitType, String whitelistSite) {
|
org.apache.poi.ss.usermodel.Row row = sheet.createRow(index);
|
row.createCell(0).setCellValue(phone);
|
row.createCell(1).setCellValue(benefitType);
|
row.createCell(2).setCellValue(whitelistSite);
|
}
|
}
|
