快照接口 isRepositoryExists单元测试

好的，为了编写 restoreSnapshotIndices 方法的单元测试，我们需要考虑以下几个方面：

1. 准备测试数据：创建一个 RestoreSnapshotIndicesRequest 对象，包含多个 SnapShotDTO 对象。
2. 模拟依赖服务：使用 Mockito 模拟 restHighLevelClient 和 indicesRestoreMapper 等依赖服务的行为。
3. 执行测试：调用 restoreSnapshotIndices 方法并验证其行为。
4. 验证结果：检查方法的返回值和依赖服务的调用次数等。

以下是具体的单元测试代码示例：

单元测试代码

package com.example.service.impl;

import com.example.entity.RestoreSnapshotIndicesRequest;
import com.example.entity.SnapShotDTO;
import com.example.entity.IndicesRestore;
import com.example.entity.IndicesRestoreRecord;
import com.example.exception.TitanException;
import com.example.mapper.IndicesRestoreMapper;
import com.example.mapper.IndicesRestoreRecordMapper;
import com.example.service.ElasticSearchService;
import com.example.service.SnapshotService;
import org.elasticsearch.action.admin.indices.close.CloseIndexRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.restore.RestoreSnapshotRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.core.AcknowledgedResponse;
import org.elasticsearch.snapshots.GetRepositoriesRequest;
import org.elasticsearch.snapshots.GetRepositoriesResponse;
import org.elasticsearch.snapshots.RestoreSnapshotResponse;
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.io.IOException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

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

class SnapshotServiceImplTest {

    @Mock
    private RestHighLevelClient restHighLevelClient;

    @Mock
    private ElasticSearchService elasticSearchService;

    @Mock
    private IndicesRestoreMapper indicesRestoreMapper;

    @Mock
    private IndicesRestoreRecordMapper indicesRestoreRecordMapper;

    @InjectMocks
    private SnapshotServiceImpl snapshotService;

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

    @Test
    void testRestoreSnapshotIndicesSuccess() throws IOException {
        // 准备测试数据
        SnapShotDTO snapShotDTO1 = new SnapShotDTO();
        snapShotDTO1.setRepositoryName("repo1");
        snapShotDTO1.setSnapshotName("snap1");
        snapShotDTO1.setIndices(Arrays.asList("index1", "index2"));
        snapShotDTO1.setDelDate(new Date());

        SnapShotDTO snapShotDTO2 = new SnapShotDTO();
        snapShotDTO2.setRepositoryName("repo2");
        snapShotDTO2.setSnapshotName("snap2");
        snapShotDTO2.setIndices(Arrays.asList("index3", "index4"));
        snapShotDTO2.setDelDate(new Date());

        RestoreSnapshotIndicesRequest request = new RestoreSnapshotIndicesRequest();
        request.setSnapShotList(Arrays.asList(snapShotDTO1, snapShotDTO2));

        // 模拟依赖服务的行为
        doNothing().when(restHighLevelClient).snapshot().restore(any(RestoreSnapshotRequest.class), any(RequestOptions.class));
        doReturn(true).when(elasticSearchService).isIndexExist(anyString());
        doReturn(new AcknowledgedResponse(true)).when(restHighLevelClient).indices().delete(any(DeleteIndexRequest.class), any(RequestOptions.class));
        doReturn(new AcknowledgedResponse(true)).when(restHighLevelClient).indices().close(any(CloseIndexRequest.class), any(RequestOptions.class));
        doReturn(true).when(snapshotService).isRepositoryExists(anyString());

        // 执行测试
        RestoreSnapshotIndicesResponse response = snapshotService.restoreSnapshotIndices(request);

        // 验证结果
        assertEquals(0, response.getSuccess());
        verify(restHighLevelClient, times(2)).snapshot().restore(any(RestoreSnapshotRequest.class), any(RequestOptions.class));
        verify(indicesRestoreMapper, times(4)).insert(any(IndicesRestore.class));
        verify(indicesRestoreRecordMapper, times(2)).updateByExampleSelective(any(IndicesRestoreRecord.class), any());
    }

    @Test
    void testRestoreSnapshotIndicesFailure() throws IOException {
        // 准备测试数据
        SnapShotDTO snapShotDTO1 = new SnapShotDTO();
        snapShotDTO1.setRepositoryName("repo1");
        snapShotDTO1.setSnapshotName("snap1");
        snapShotDTO1.setIndices(Arrays.asList("index1", "index2"));
        snapShotDTO1.setDelDate(new Date());

        RestoreSnapshotIndicesRequest request = new RestoreSnapshotIndicesRequest();
        request.setSnapShotList(Arrays.asList(snapShotDTO1));

        // 模拟依赖服务的行为
        doThrow(new IOException("Simulated IO Exception")).when(restHighLevelClient).snapshot().restore(any(RestoreSnapshotRequest.class), any(RequestOptions.class));

        // 执行测试
        RestoreSnapshotIndicesResponse response = snapshotService.restoreSnapshotIndices(request);

        // 验证结果
        assertEquals(-1, response.getSuccess());
        verify(restHighLevelClient, times(1)).snapshot().restore(any(RestoreSnapshotRequest.class), any(RequestOptions.class));
        verify(indicesRestoreMapper, never()).insert(any(IndicesRestore.class));
        verify(indicesRestoreRecordMapper, never()).updateByExampleSelective(any(IndicesRestoreRecord.class), any());
    }

    @Test
    void testRestoreSnapshotIndicesWithNullRequest() {
        // 执行测试
        assertThrows(TitanException.class, () -> snapshotService.restoreSnapshotIndices(null));
    }

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

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

    @Test
    void testRestoreSnapshotIndicesWithEmptySnapShotList() {
        // 准备测试数据
        RestoreSnapshotIndicesRequest request = new RestoreSnapshotIndicesRequest();
        request.setSnapShotList(Arrays.asList());

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

解释

1. 准备测试数据：

   • 创建了两个 SnapShotDTO 对象，分别设置仓库名称、快照名称、索引列表和删除日期。
   • 创建一个 RestoreSnapshotIndicesRequest 对象，并设置 SnapShotDTO 列表。

2. 模拟依赖服务的行为：

   • 使用 doNothing 模拟 restHighLevelClient.snapshot().restore 方法的行为。
   • 使用 doReturn 模拟 elasticSearchService.isIndexExist、restHighLevelClient.indices().delete、restHighLevelClient.indices().close 和 snapshotService.isRepositoryExists 方法的行为。

3. 执行测试：

   • 调用 snapshotService.restoreSnapshotIndices 方法并传递准备好的请求对象。
   • 验证方法的返回值和依赖服务的调用次数。

4. 验证结果：

   • 使用 assertEquals 验证返回值。
   • 使用 verify 验证依赖服务的调用次数。

5. 异常测试：

   • 测试 restoreSnapshotIndices 方法在接收到 null 请求、空请求和空 SnapShotDTO 列表时的行为，确保抛出 TitanException。

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