IpAddressService ip地址参数校验 allIpAddressCheck 单元测试

当然，我可以帮助您修改所有的单元测试代码，以确保它们都能正确地使用 doAnswer 方法来模拟 void 返回类型的方法。以下是修改后的所有单元测试代码：

package com.example.service.impl;

import com.example.entity.AllIpAddressCheckRequest;
import com.example.entity.AllIpAddressCheckResponse;
import com.example.exception.TitanException;
import com.example.service.IpAddressService;
import com.example.service.IpCheckService;
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.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;

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

class IpAddressServiceImplTest {

    @Mock
    private IpCheckService ipCheckService;

    @InjectMocks
    private IpAddressService ipAddressService = new IpAddressServiceImpl();

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

    @Test
    void testAllIpAddressCheckWithValidIps() throws InterruptedException {
        // 准备测试数据
        AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
        request.setIpAddressList(Arrays.asList("192.168.1.1", "10.0.0.1"));

        // 使用 doAnswer 而不是 thenAnswer
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                String ipAddress = invocation.getArgument(0);
                Map<String, Boolean> map = invocation.getArgument(1);
                CountDownLatch latch = invocation.getArgument(2);
                map.put(ipAddress, true);
                latch.countDown();
                return null; // 注意这里返回 null
            }
        }).when(ipCheckService).asyncIpCheck(anyString(), anyMap(), any(CountDownLatch.class));

        // 执行测试
        AllIpAddressCheckResponse response = ipAddressService.allIpAddressCheck(request);

        // 验证结果
        assertTrue(response.getResult());
        assertEquals(2, response.getMap().size());
        assertTrue(response.getMap().get("192.168.1.1"));
        assertTrue(response.getMap().get("10.0.0.1"));
    }

    @Test
    void testAllIpAddressCheckWithInvalidIps() {
        // 准备测试数据
        AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
        request.setIpAddressList(Arrays.asList("192.168.1.1", "invalid-ip"));

        // 使用 doAnswer 而不是 thenAnswer
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                String ipAddress = invocation.getArgument(0);
                Map<String, Boolean> map = invocation.getArgument(1);
                CountDownLatch latch = invocation.getArgument(2);
                if (ipAddress.equals("192.168.1.1")) {
                    map.put(ipAddress, true);
                } else {
                    map.put(ipAddress, false);
                }
                latch.countDown();
                return null; // 注意这里返回 null
            }
        }).when(ipCheckService).asyncIpCheck(anyString(), anyMap(), any(CountDownLatch.class));

        // 执行测试
        assertThrows(TitanException.class, () -> ipAddressService.allIpAddressCheck(request));
    }

    @Test
    void testAllIpAddressCheckWithEmptyRequest() {
        // 准备测试数据
        AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();

        // 执行测试
        assertThrows(TitanException.class, () -> ipAddressService.allIpAddressCheck(request));
    }

    @Test
    void testAllIpAddressCheckWithNullRequest() {
        // 执行测试
        assertThrows(TitanException.class, () -> ipAddressService.allIpAddressCheck(null));
    }

    @Test
    void testAllIpAddressCheckWithEmptyIpList() {
        // 准备测试数据
        AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
        request.setIpAddressList(new ArrayList<>());

        // 执行测试
        assertThrows(TitanException.class, () -> ipAddressService.allIpAddressCheck(request));
    }

    @Test
    void testAllIpAddressCheckWithInvalidIpFormat() {
        // 准备测试数据
        AllIpAddressCheckRequest request = new AllIpAddressCheckRequest();
        request.setIpAddressList(Arrays.asList("192.168.1.1", "256.0.0.1"));

        // 使用 doAnswer 而不是 thenAnswer
        doAnswer(new Answer<Void>() {
            @Override
            public Void answer(InvocationOnMock invocation) throws Throwable {
                String ipAddress = invocation.getArgument(0);
                Map<String, Boolean> map = invocation.getArgument(1);
                CountDownLatch latch = invocation.getArgument(2);
                if (ipAddress.equals("192.168.1.1")) {
                    map.put(ipAddress, true);
                } else {
                    map.put(ipAddress, false);
                }
                latch.countDown();
                return null; // 注意这里返回 null
            }
        }).when(ipCheckService).asyncIpCheck(anyString(), anyMap(), any(CountDownLatch.class));

        // 执行测试
        assertThrows(TitanException.class, () -> ipAddressService.allIpAddressCheck(request));
    }
}

解释

1. testAllIpAddressCheckWithValidIps:

   • 模拟 asyncIpCheck 方法，使所有 IP 地址检查成功。
   • 验证返回结果中的所有 IP 地址都检查成功。

2. testAllIpAddressCheckWithInvalidIps:

   • 模拟 asyncIpCheck 方法，使无效 IP 地址检查失败。
   • 验证 allIpAddressCheck 方法在有无效 IP 地址时抛出 TitanException。

3. testAllIpAddressCheckWithEmptyRequest:

   • 测试空请求对象的情况。
   • 验证 allIpAddressCheck 方法在请求对象为空时抛出 TitanException。

4. testAllIpAddressCheckWithNullRequest:

   • 测试请求对象为 null 的情况。
   • 验证 allIpAddressCheck 方法在请求对象为 null 时抛出 TitanException。

5. testAllIpAddressCheckWithEmptyIpList:

   • 测试 IP 地址列表为空的情况。
   • 验证 allIpAddressCheck 方法在 IP 地址列表为空时抛出 TitanException。

6. testAllIpAddressCheckWithInvalidIpFormat:

   • 模拟 asyncIpCheck 方法，使无效格式的 IP 地址检查失败。
   • 验证 allIpAddressCheck 方法在有无效格式的 IP 地址时抛出 TitanException。

这些测试用例覆盖了多种不同的输入情况，确保 allIpAddressCheck 方法在不同情况下都能正确处理。