328 lines
12 KiB
Java
328 lines
12 KiB
Java
package cd.casic.server;
|
|
|
|
import cd.casic.ci.process.dto.req.resource.ResourceReq;
|
|
import cd.casic.ci.process.dto.resp.resource.ResourceFindResp;
|
|
import cd.casic.ci.process.process.converter.ResourceConverter;
|
|
import cd.casic.ci.process.process.dao.pipeline.PipResourceCloudDao;
|
|
import cd.casic.ci.process.process.dao.pipeline.PipResourceK8SDao;
|
|
import cd.casic.ci.process.process.dao.pipeline.PipResourceMachineDao;
|
|
import cd.casic.ci.process.process.dao.pipeline.PipResourceManagerDao;
|
|
import cd.casic.ci.process.process.dataObject.resource.PipResourceCloud;
|
|
import cd.casic.ci.process.process.dataObject.resource.PipResourceK8S;
|
|
import cd.casic.ci.process.process.dataObject.resource.PipResourceMachine;
|
|
import cd.casic.ci.process.process.dataObject.resource.PipResourceManager;
|
|
import cd.casic.ci.process.process.service.resource.impl.ResourceManagerServiceImpl;
|
|
import cd.casic.module.execute.docker.dao.DockerEndpointDao;
|
|
import cd.casic.module.execute.docker.dataobject.dto.DockerEndpointDo;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.junit.jupiter.api.Test;
|
|
import org.mockito.Mockito;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.boot.test.context.SpringBootTest;
|
|
import org.springframework.boot.test.mock.mockito.MockBean;
|
|
import org.springframework.test.context.ActiveProfiles;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertNull;
|
|
import static org.mockito.ArgumentMatchers.any;
|
|
import static org.mockito.ArgumentMatchers.anyString;
|
|
import static org.mockito.Mockito.*;
|
|
|
|
@SpringBootTest(classes = {OpsServerApplication.class})
|
|
@ActiveProfiles("local")
|
|
@Slf4j
|
|
public class ResourceTest {
|
|
@Autowired
|
|
private ResourceManagerServiceImpl resourceManagerService;
|
|
|
|
@MockBean
|
|
private PipResourceManagerDao pipResourceManagerDao;
|
|
|
|
@MockBean
|
|
private PipResourceMachineDao machineDao;
|
|
|
|
@MockBean
|
|
private PipResourceK8SDao k8SDao;
|
|
|
|
@MockBean
|
|
private DockerEndpointDao dockerEndpointDao;
|
|
|
|
@MockBean
|
|
private PipResourceCloudDao cloudDao;
|
|
|
|
@MockBean
|
|
private ResourceConverter resourceConverter;
|
|
|
|
@Test
|
|
void testCreateResourceWithMachine() {
|
|
// Arrange
|
|
ResourceReq resourceReq = new ResourceReq();
|
|
PipResourceMachine resourceMachine = new PipResourceMachine();
|
|
resourceMachine.setId("machineId");
|
|
resourceReq.setResourceMachine(resourceMachine);
|
|
|
|
when(machineDao.insert(any(PipResourceMachine.class))).thenAnswer(invocation -> {
|
|
PipResourceMachine machine = invocation.getArgument(0);
|
|
machine.setId("machineId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
|
|
PipResourceManager manager = invocation.getArgument(0);
|
|
manager.setId("resourceId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
// Act
|
|
String result = resourceManagerService.createResource(resourceReq);
|
|
|
|
// Assert
|
|
verify(machineDao, times(1)).insert(any(PipResourceMachine.class));
|
|
verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));
|
|
|
|
// 验证返回的ID
|
|
assert result.equals("resourceId");
|
|
}
|
|
|
|
@Test
|
|
void testCreateResourceWithK8s() {
|
|
// Arrange
|
|
ResourceReq resourceReq = new ResourceReq();
|
|
PipResourceK8S pipResourceK8S = new PipResourceK8S();
|
|
pipResourceK8S.setId("k8sId");
|
|
resourceReq.setPipResourceK8S(pipResourceK8S);
|
|
|
|
when(k8SDao.insert(any(PipResourceK8S.class))).thenAnswer(invocation -> {
|
|
PipResourceK8S k8s = invocation.getArgument(0);
|
|
k8s.setId("k8sId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
|
|
PipResourceManager manager = invocation.getArgument(0);
|
|
manager.setId("resourceId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
// Act
|
|
String result = resourceManagerService.createResource(resourceReq);
|
|
|
|
// Assert
|
|
verify(k8SDao, times(1)).insert(any(PipResourceK8S.class));
|
|
verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));
|
|
|
|
// 验证返回的ID
|
|
assert result.equals("resourceId");
|
|
}
|
|
|
|
@Test
|
|
void testCreateResourceWithDocker() {
|
|
// Arrange
|
|
ResourceReq resourceReq = new ResourceReq();
|
|
DockerEndpointDo dockerEndpoint = new DockerEndpointDo();
|
|
dockerEndpoint.setId("dockerId");
|
|
resourceReq.setDockerEndpoint(dockerEndpoint);
|
|
|
|
when(dockerEndpointDao.insert(any(DockerEndpointDo.class))).thenAnswer(invocation -> {
|
|
DockerEndpointDo endpoint = invocation.getArgument(0);
|
|
endpoint.setId("dockerId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
|
|
PipResourceManager manager = invocation.getArgument(0);
|
|
manager.setId("resourceId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
// Act
|
|
String result = resourceManagerService.createResource(resourceReq);
|
|
|
|
// Assert
|
|
verify(dockerEndpointDao, times(1)).insert(any(DockerEndpointDo.class));
|
|
verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));
|
|
|
|
// 验证返回的ID
|
|
assert result.equals("resourceId");
|
|
}
|
|
|
|
@Test
|
|
void testCreateResourceWithCloud() {
|
|
// Arrange
|
|
ResourceReq resourceReq = new ResourceReq();
|
|
PipResourceCloud pipResourceCloud = new PipResourceCloud();
|
|
pipResourceCloud.setId("cloudId");
|
|
resourceReq.setPipResourceCloud(pipResourceCloud);
|
|
|
|
when(cloudDao.insert(any(PipResourceCloud.class))).thenAnswer(invocation -> {
|
|
PipResourceCloud cloud = invocation.getArgument(0);
|
|
cloud.setId("cloudId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
when(pipResourceManagerDao.insert(any(PipResourceManager.class))).thenAnswer(invocation -> {
|
|
PipResourceManager manager = invocation.getArgument(0);
|
|
manager.setId("resourceId"); // 模拟插入后生成ID
|
|
return null;
|
|
});
|
|
|
|
// Act
|
|
String result = resourceManagerService.createResource(resourceReq);
|
|
|
|
// Assert
|
|
verify(cloudDao, times(1)).insert(any(PipResourceCloud.class));
|
|
verify(pipResourceManagerDao, times(1)).insert(any(PipResourceManager.class));
|
|
|
|
// 验证返回的ID
|
|
assert result.equals("resourceId");
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
void testDeleteResource_WithAllSubResources() {
|
|
// Arrange
|
|
String resourceId = "res123";
|
|
PipResourceManager pipResourceManager = new PipResourceManager();
|
|
pipResourceManager.setId(resourceId);
|
|
pipResourceManager.setMachineId("machine123");
|
|
pipResourceManager.setK8sId("k8s123");
|
|
pipResourceManager.setDockerId("docker123");
|
|
pipResourceManager.setCloudId("cloud123");
|
|
|
|
Mockito.when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);
|
|
|
|
// Act
|
|
resourceManagerService.deleteResource(resourceId);
|
|
|
|
// Assert
|
|
Mockito.verify(machineDao, Mockito.times(1)).deleteById("machine123");
|
|
Mockito.verify(k8SDao, Mockito.times(1)).deleteById("k8s123");
|
|
Mockito.verify(dockerEndpointDao, Mockito.times(1)).deleteById("docker123");
|
|
Mockito.verify(cloudDao, Mockito.times(1)).deleteById("cloud123");
|
|
Mockito.verify(pipResourceManagerDao, Mockito.times(1)).deleteById(resourceId);
|
|
}
|
|
|
|
@Test
|
|
void testDeleteResource_WithOnlyMachineResource() {
|
|
// Arrange
|
|
String resourceId = "res123";
|
|
PipResourceManager pipResourceManager = new PipResourceManager();
|
|
pipResourceManager.setId(resourceId);
|
|
pipResourceManager.setMachineId("machine123");
|
|
|
|
Mockito.when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);
|
|
|
|
// Act
|
|
resourceManagerService.deleteResource(resourceId);
|
|
|
|
// Assert
|
|
Mockito.verify(machineDao, Mockito.times(1)).deleteById("machine123");
|
|
Mockito.verify(k8SDao, never()).deleteById(anyString());
|
|
Mockito.verify(dockerEndpointDao, never()).deleteById(anyString());
|
|
Mockito.verify(cloudDao, never()).deleteById(anyString());
|
|
Mockito.verify(pipResourceManagerDao, Mockito.times(1)).deleteById(resourceId);
|
|
}
|
|
|
|
@Test
|
|
void testDeleteResource_ResourceNotFound() {
|
|
// Arrange
|
|
String resourceId = "nonExistent";
|
|
|
|
Mockito.when(pipResourceManagerDao.selectById(resourceId)).thenReturn(null);
|
|
|
|
// Act & Assert
|
|
try {
|
|
resourceManagerService.deleteResource(resourceId);
|
|
} catch (Exception e) {
|
|
// Expect no exception, just skip deletion
|
|
}
|
|
|
|
Mockito.verify(machineDao, never()).deleteById(anyString());
|
|
Mockito.verify(k8SDao, never()).deleteById(anyString());
|
|
Mockito.verify(dockerEndpointDao, never()).deleteById(anyString());
|
|
Mockito.verify(cloudDao, never()).deleteById(anyString());
|
|
Mockito.verify(pipResourceManagerDao, never()).deleteById(anyString());
|
|
}
|
|
|
|
|
|
@Test
|
|
void testDeleteResourceWithAllSubResources() {
|
|
// Arrange
|
|
String resourceId = "resourceId";
|
|
PipResourceManager pipResourceManager = new PipResourceManager();
|
|
pipResourceManager.setId(resourceId);
|
|
pipResourceManager.setMachineId("machineId");
|
|
pipResourceManager.setK8sId("k8sId");
|
|
pipResourceManager.setDockerId("dockerId");
|
|
pipResourceManager.setCloudId("cloudId");
|
|
|
|
when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);
|
|
|
|
// Act
|
|
resourceManagerService.deleteResource(resourceId);
|
|
|
|
// Assert
|
|
verify(pipResourceManagerDao, times(1)).selectById(resourceId);
|
|
verify(machineDao, times(1)).deleteById("machineId");
|
|
verify(k8SDao, times(1)).deleteById("k8sId");
|
|
verify(dockerEndpointDao, times(1)).deleteById("dockerId");
|
|
verify(cloudDao, times(1)).deleteById("cloudId");
|
|
verify(pipResourceManagerDao, times(1)).deleteById(resourceId);
|
|
}
|
|
|
|
@Test
|
|
void testDeleteResourceWithOnlyMachine() {
|
|
// Arrange
|
|
String resourceId = "resourceId";
|
|
PipResourceManager pipResourceManager = new PipResourceManager();
|
|
pipResourceManager.setId(resourceId);
|
|
pipResourceManager.setMachineId("machineId");
|
|
|
|
when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);
|
|
|
|
// Act
|
|
resourceManagerService.deleteResource(resourceId);
|
|
|
|
// Assert
|
|
verify(pipResourceManagerDao, times(1)).selectById(resourceId);
|
|
verify(machineDao, times(1)).deleteById("machineId");
|
|
verify(k8SDao, never()).deleteById(anyString());
|
|
verify(dockerEndpointDao, never()).deleteById(anyString());
|
|
verify(cloudDao, never()).deleteById(anyString());
|
|
verify(pipResourceManagerDao, times(1)).deleteById(resourceId);
|
|
}
|
|
|
|
@Test
|
|
void testDeleteResourceWithNoSubResources() {
|
|
// Arrange
|
|
String resourceId = "resourceId";
|
|
PipResourceManager pipResourceManager = new PipResourceManager();
|
|
pipResourceManager.setId(resourceId);
|
|
|
|
when(pipResourceManagerDao.selectById(resourceId)).thenReturn(pipResourceManager);
|
|
|
|
// Act
|
|
resourceManagerService.deleteResource(resourceId);
|
|
|
|
// Assert
|
|
verify(pipResourceManagerDao, times(1)).selectById(resourceId);
|
|
verify(machineDao, never()).deleteById(anyString());
|
|
verify(k8SDao, never()).deleteById(anyString());
|
|
verify(dockerEndpointDao, never()).deleteById(anyString());
|
|
verify(cloudDao, never()).deleteById(anyString());
|
|
verify(pipResourceManagerDao, times(1)).deleteById(resourceId);
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
void testFindResourceById_ResourceExists() {
|
|
|
|
ResourceFindResp resourceById = resourceManagerService.findResourceById("1");
|
|
|
|
assertNull(resourceById);
|
|
}
|
|
|
|
|
|
}
|