IpAdressServiceImpl的测试

import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;

import static org.junit.jupiter.api.Assertions.;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.;

@Slf4j
class IpAddressServiceImplTest {

@Mock
private IpCheckService ipCheckService;

@InjectMocks
private IpAddressServiceImpl ipAddressService;

@BeforeEach
void setUp() {
    MockitoAnnotations.openMocks(this);
}

@Test
void testAllIpAddressCheck_Success() throws InterruptedException {
    // Arrange
    AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
    List<String> ipAddressList = Collections.singletonList("192.168.1.1");
    request.setIpAddressList(ipAddressList);

    Map<String, Boolean> map = new ConcurrentHashMap<>();
    CountDownLatch latch = new CountDownLatch(1);

    doNothing().when(ipCheckService).asyncIpCheck(anyString(), anyMap(), eq(latch));

    // Act
    AllIpAddressCheckResponse response = ipAddressService.alllpAddressCheck(request);

    // Assert
    assertTrue(response.isSuccess());
    assertNotNull(response.getMap());
    assertEquals(1, response.getMap().size());
    assertTrue(response.getMap().get("192.168.1.1"));
}

@Test
void testAllIpAddressCheck_EmptyIpAddressList() {
    // Arrange
    AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
    request.setIpAddressList(Collections.emptyList());

    // Act & Assert
    Exception exception = assertThrows(TitanException.class, () -> {
        ipAddressService.alllpAddressCheck(request);
    });

    // Assert
    assertEquals("所传参数为空!", exception.getMessage());
}

@Test
void testAllIpAddressCheck_NullIpAddressList() {
    // Arrange
    AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
    request.setIpAddressList(null);

    // Act & Assert
    Exception exception = assertThrows(TitanException.class, () -> {
        ipAddressService.alllpAddressCheck(request);
    });

    // Assert
    assertEquals("所传参数为空!", exception.getMessage());
}

@Test
void testAllIpAddressCheck_InvalidIpAddressFormat() {
    // Arrange
    AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
    List<String> ipAddressList = Collections.singletonList("invalid_ip");
    request.setIpAddressList(ipAddressList);

    // Act & Assert
    Exception exception = assertThrows(TitanException.class, () -> {
        ipAddressService.alllpAddressCheck(request);
    });

    // Assert
    assertEquals("所传 ip 地址格式错误", exception.getMessage());
}

@Test
void testAllIpAddressCheck_IpCheckFailure() throws InterruptedException {
    // Arrange
    AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
    List<String> ipAddressList = Collections.singletonList("192.168.1.1");
    request.setIpAddressList(ipAddressList);

    Map<String, Boolean> map = new ConcurrentHashMap<>();
    CountDownLatch latch = new CountDownLatch(1);

    doThrow(new TitanException("IP校验异常")).when(ipCheckService).asyncIpCheck(anyString(), anyMap(), eq(latch));

    // Act & Assert
    Exception exception = assertThrows(TitanException.class, () -> {
        ipAddressService.alllpAddressCheck(request);
    });

    // Assert
    assertEquals("IP校验异常", exception.getMessage());
}

}

// 辅助类和枚举类的假定实现

class AllIpAddressCheckRequest {
private List ipAddressList;

public List<String> getIpAddressList() {
    return ipAddressList;
}

public void setIpAddressList(List<String> ipAddressList) {
    this.ipAddressList = ipAddressList;
}

}

class AllIpAddressCheckResponse extends BaseResponse {
private HashMap<String, Boolean> map;

public HashMap<String, Boolean> getMap() {
    return map;
}

public void setMap(HashMap<String, Boolean> map) {
    this.map = map;
}

}

abstract class BaseResponse {
private boolean success;
private String errCode;
private String errMsg;

public boolean isSuccess() {
    return success;
}

public void setSuccess() {
    this.success = true;
}

public String getErrCode() {
    return errCode;
}

public void setErrCode(String errCode) {
    this.errCode = errCode;
}

public String getErrMsg() {
    return errMsg;
}

public void setErrMsg(String errMsg) {
    this.errMsg = errMsg;
}

}

class RespUtils {
private static final Logger log = LoggerFactory.getLogger(RespUtils.class);

private RespUtils() {}

public static void setSuccess(BaseResponse response) {
    response.setSuccess();
}

public static void setError(Exception e, ErrCodeBaseEnum errCode, BaseResponse response) {
    if (e instanceof BaseBizException) {
        BaseBizException exception = (BaseBizException) e;
        response.setErrCode(exception.getErrCode());
        response.setErrMsg(exception.getErrMsg());
    } else if (errCode != null) {
        response.setErrCode(errCode.getErrCode());
        response.setErrMsg(errCode.getErrMsg());
    } else {
        log.error("errCode为空, 设置默认错误");
        response.setErrCode(HadesErrCodeEnum.BIZ_UNKNOWN_ERROR.getErrCode());
        response.setErrMsg(HadesErrCodeEnum.BIZ_UNKNOWN_ERROR.getErrMsg());
    }
}

public static void setError(ErrCodeBaseEnum errCode, BaseResponse response) {
    setError((Exception) null, errCode, response);
}

public static Object newReturn(Class<?> returnType, String errCode, String errMsg) {
    if (returnType == null) {
        return null;
    } else {
        Object ret = null;
        try {
            ret = returnType.newInstance();
            if (ret instanceof BaseResponse) {
                BaseResponse response = (BaseResponse) ret;
                response.setErrCode(errCode);
                response.setErrMsg(errMsg);
                ret = response;
            }
        } catch (IllegalAccessException | InstantiationException var5) {
            log.info((String) null, var5);
        }
        return ret;
    }
}

public static Object newReturn(Class<?> returnType, BaseBizException e) {
    return newReturn(returnType, e.getErrCode(), e.getErrMsg());
}

public static Object newReturn(Class<?> returnType, ErrCodeBaseEnum errCodeBaseEnum) {
    return newReturn(returnType, errCodeBaseEnum.getErrCode(), errCodeBaseEnum.getErrMsg());
}

}

class TitanException extends RuntimeException {
public TitanException() {
super();
}

public TitanException(String message) {
    super(message);
}

public TitanException(String message, Throwable cause) {
    super(message, cause);
}

public TitanException(Throwable cause) {
    super(cause);
}

}

class IpCheckService {
@Async(value = "asyncIpCheckExecutor")
public void asyncIpCheck(String ipAddress, Map<String, Boolean> map, CountDownLatch latch) {
try {
InetAddress address = InetAddress.getByName(ipAddress);
map.put(ipAddress, true);
if (address.isReachable(3000)) {
map.put(ipAddress, false);
}
} catch (Exception e) {
log.error("IP校验异常", e);
throw new TitanException("IP校验异常", e);
} finally {
latch.countDown();
}
}
}

interface ErrCodeBaseEnum {
String getErrCode();

String getErrMsg();

}

enum HadesErrCodeEnum implements ErrCodeBaseEnum {
BIZ_UNKNOWN_ERROR("UNKNOWN_ERROR", "未知错误");

private final String errCode;
private final String errMsg;

HadesErrCodeEnum(String errCode, String errMsg) {
    this.errCode = errCode;
    this.errMsg = errMsg;
}

@Override
public String getErrCode() {
    return errCode;
}

@Override
public String getErrMsg() {
    return errMsg;
}

}

class BaseBizException extends RuntimeException {
private String errCode;
private String errMsg;

public BaseBizException(String errCode, String errMsg) {
    super(errMsg);
    this.errCode = errCode;
    this.errMsg = errMsg;
}

public String getErrCode() {
    return errCode;
}

public String getErrMsg() {
    return errMsg;
}

}

@Service("ipAddressService")
class IpAddressServiceImpl implements IpAddressService {
@Autowired
private IpCheckService ipCheckService;

@Override
public AllIpAddressCheckResponse alllpAddressCheck(AllIpAddressCheckRequest request) {
    AllIpAddressCheckResponse response = new AllIpAddressCheckResponse();
    Map<String, Boolean> map = new ConcurrentHashMap<>();
    List<String> ipAddressList = request.getIpAddressList();
    response.setResult(true);
    if (ipAddressList == null || ipAddressList.isEmpty()) {
        throw new TitanException("所传参数为空!");
    }
    Set<String> ipAddressSet = new HashSet<>(ipAddressList);
    CountDownLatch latch = new CountDownLatch(ipAddressSet.size());
    try {
        for (String ipAddress : ipAddressSet) {
            if (ipAddress == null || ipAddress.isEmpty()) {
                throw new TitanException("所传 ip地址为空");
            }
            if (!ipAddressCheck(ipAddress)) {
                throw new TitanException("所传 ip 地址格式错误");
            }
            ipCheckService.asyncIpCheck(ipAddress, map, latch);
        }
        latch.await();
        map.keySet().forEach(key -> {
            if (!map.get(key)) {
                response.setResult(false);
            }
        });
        HashMap<String, Boolean> hashMap = Maps.newHashMap(map);
        response.setMap(hashMap);
        RespUtils.setSuccess(response);
    } catch (InterruptedException e) {
        log.error("IP检验线程数据同步异常", e);
        throw new TitanException("IP检验线程数据同步异常", e);
    } catch (Exception e) {
        log.error("IP检验异常", e);
        throw new TitanException("IP检验异常", e);
    }
    return response;
}

private static boolean ipAddressCheck(String ipAddress) {
    return ipAddress.matches("^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\. "
            + "((1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[0-9])\\.){2}"
            + "(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[0-9])$");
}

}